Use Job information in Acquire and Prolong

Implement AcquireWorker and ProlongAccess in ReqsCollection.
Adjust tests to the usage of JobsManager in AcquireWorker
and cover new functionality.

Usage of mocked up JobsManager in tests is required.
The MockJobsManager has been generated using command:

mockgen	-package requests \
	-destination=requests/jobsmanager_mock_test.go \
	-write_package_comment=false \
	git.tizen.org/tools/boruta/matcher JobsManager

Change-Id: Ia925e556ddbb86a7998e982d760901e9e80666f2
Signed-off-by: Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>

diff --git a/requests/jobsmanager_mock_test.go b/requests/jobsmanager_mock_test.go
new file mode 100644 (file)
index 0000000..f4eb36f
--- /dev/null
+++ b/requests/jobsmanager_mock_test.go
@@ -0,0 +1,71 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: git.tizen.org/tools/boruta/matcher (interfaces: JobsManager)
+
+package requests
+
+import (
+       boruta "git.tizen.org/tools/boruta"
+       workers "git.tizen.org/tools/boruta/workers"
+       gomock "github.com/golang/mock/gomock"
+       reflect "reflect"
+)
+
+// MockJobsManager is a mock of JobsManager interface
+type MockJobsManager struct {
+       ctrl     *gomock.Controller
+       recorder *MockJobsManagerMockRecorder
+}
+
+// MockJobsManagerMockRecorder is the mock recorder for MockJobsManager
+type MockJobsManagerMockRecorder struct {
+       mock *MockJobsManager
+}
+
+// NewMockJobsManager creates a new mock instance
+func NewMockJobsManager(ctrl *gomock.Controller) *MockJobsManager {
+       mock := &MockJobsManager{ctrl: ctrl}
+       mock.recorder = &MockJobsManagerMockRecorder{mock}
+       return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockJobsManager) EXPECT() *MockJobsManagerMockRecorder {
+       return m.recorder
+}
+
+// Create mocks base method
+func (m *MockJobsManager) Create(arg0 boruta.ReqID, arg1 boruta.WorkerUUID) error {
+       ret := m.ctrl.Call(m, "Create", arg0, arg1)
+       ret0, _ := ret[0].(error)
+       return ret0
+}
+
+// Create indicates an expected call of Create
+func (mr *MockJobsManagerMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
+       return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockJobsManager)(nil).Create), arg0, arg1)
+}
+
+// Finish mocks base method
+func (m *MockJobsManager) Finish(arg0 boruta.WorkerUUID) error {
+       ret := m.ctrl.Call(m, "Finish", arg0)
+       ret0, _ := ret[0].(error)
+       return ret0
+}
+
+// Finish indicates an expected call of Finish
+func (mr *MockJobsManagerMockRecorder) Finish(arg0 interface{}) *gomock.Call {
+       return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finish", reflect.TypeOf((*MockJobsManager)(nil).Finish), arg0)
+}
+
+// Get mocks base method
+func (m *MockJobsManager) Get(arg0 boruta.WorkerUUID) (*workers.Job, error) {
+       ret := m.ctrl.Call(m, "Get", arg0)
+       ret0, _ := ret[0].(*workers.Job)
+       ret1, _ := ret[1].(error)
+       return ret0, ret1
+}
+
+// Get indicates an expected call of Get
+func (mr *MockJobsManagerMockRecorder) Get(arg0 interface{}) *gomock.Call {
+       return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockJobsManager)(nil).Get), arg0)
+}

diff --git a/requests/requests.go b/requests/requests.go
index 5592e31..adc93fb 100644 (file)
--- a/requests/requests.go
+++ b/requests/requests.go
@@ -278,8 +278,12 @@ func (reqs *ReqsCollection) AcquireWorker(reqID ReqID) (AccessInfo, error) {
        if req.State != INPROGRESS || req.Job == nil {
                return AccessInfo{}, ErrWorkerNotAssigned
        }
-       // TODO(mwereski): create job and get access info
-       return AccessInfo{}, nil
+
+       job, err := reqs.jobs.Get(req.Job.WorkerUUID)
+       if err != nil {
+               return AccessInfo{}, err
+       }
+       return job.Access, nil
 }
 
 // ProlongAccess is part of implementation of Requests interface. When owner of
@@ -295,7 +299,14 @@ func (reqs *ReqsCollection) ProlongAccess(reqID ReqID) error {
        if req.State != INPROGRESS || req.Job == nil {
                return ErrWorkerNotAssigned
        }
-       // TODO(mwereski): prolong access
+
+       // TODO(mwereski) Get timeout period  from default config / user capabilities.
+       timeoutPeriod := time.Hour
+
+       // TODO(mwereski) Check if user has reached maximum prolong count for the
+       // request, store the counter somewhere and update it here.
+       req.Job.Timeout = time.Now().Add(timeoutPeriod)
+       reqs.timeoutTimes.insert(requestTime{time: req.Job.Timeout, req: reqID})
        return nil
 }
 

diff --git a/requests/requests_test.go b/requests/requests_test.go
index 3473546..30cb9c1 100644 (file)
--- a/requests/requests_test.go
+++ b/requests/requests_test.go
@@ -18,11 +18,13 @@ package requests
 
 import (
        "errors"
+       "net"
        "strconv"
        "testing"
        "time"
 
        . "git.tizen.org/tools/boruta"
+       "git.tizen.org/tools/boruta/workers"
        gomock "github.com/golang/mock/gomock"
        "github.com/stretchr/testify/assert"
 )
@@ -63,12 +65,13 @@ var requestsTests = [...]struct {
        },
 }
 
-func initTest(t *testing.T) (*assert.Assertions, *ReqsCollection, *gomock.Controller) {
+func initTest(t *testing.T) (*assert.Assertions, *ReqsCollection, *gomock.Controller, *MockJobsManager) {
        ctrl := gomock.NewController(t)
        wm := NewMockWorkersManager(ctrl)
+       jm := NewMockJobsManager(ctrl)
        testErr := errors.New("Test Error")
        wm.EXPECT().TakeBestMatchingWorker(gomock.Any(), gomock.Any()).Return(WorkerUUID(""), testErr).AnyTimes()
-       return assert.New(t), NewRequestQueue(wm, nil), ctrl
+       return assert.New(t), NewRequestQueue(wm, jm), ctrl, jm
 }
 
 func finiTest(rqueue *ReqsCollection, ctrl *gomock.Controller) {
@@ -77,7 +80,7 @@ func finiTest(rqueue *ReqsCollection, ctrl *gomock.Controller) {
 }
 
 func TestNewRequestQueue(t *testing.T) {
-       assert, rqueue, ctrl := initTest(t)
+       assert, rqueue, ctrl, _ := initTest(t)
        defer finiTest(rqueue, ctrl)
 
        rqueue.mutex.RLock()
@@ -88,7 +91,7 @@ func TestNewRequestQueue(t *testing.T) {
 }
 
 func TestNewRequest(t *testing.T) {
-       assert, rqueue, ctrl := initTest(t)
+       assert, rqueue, ctrl, _ := initTest(t)
        defer finiTest(rqueue, ctrl)
 
        for _, test := range requestsTests {
@@ -117,7 +120,7 @@ func TestNewRequest(t *testing.T) {
 }
 
 func TestCloseRequest(t *testing.T) {
-       assert, rqueue, ctrl := initTest(t)
+       assert, rqueue, ctrl, _ := initTest(t)
        defer finiTest(rqueue, ctrl)
        req := requestsTests[0].req
 
@@ -184,7 +187,7 @@ func TestCloseRequest(t *testing.T) {
 }
 
 func TestUpdateRequest(t *testing.T) {
-       assert, rqueue, ctrl := initTest(t)
+       assert, rqueue, ctrl, _ := initTest(t)
        defer finiTest(rqueue, ctrl)
        tmp := requestsTests[0].req
 
@@ -288,7 +291,7 @@ func TestUpdateRequest(t *testing.T) {
 }
 
 func TestGetRequestInfo(t *testing.T) {
-       assert, rqueue, ctrl := initTest(t)
+       assert, rqueue, ctrl, _ := initTest(t)
        defer finiTest(rqueue, ctrl)
        req := requestsTests[0].req
        req.Job = nil
@@ -329,7 +332,7 @@ func (filter *reqFilter) Match(req *ReqInfo) bool {
 }
 
 func TestListRequests(t *testing.T) {
-       assert, rqueue, ctrl := initTest(t)
+       assert, rqueue, ctrl, _ := initTest(t)
        defer finiTest(rqueue, ctrl)
        req := requestsTests[0].req
        const reqsCnt = 4
@@ -465,10 +468,12 @@ func TestListRequests(t *testing.T) {
 }
 
 func TestAcquireWorker(t *testing.T) {
-       assert, rqueue, ctrl := initTest(t)
+       assert, rqueue, ctrl, jm := initTest(t)
        defer finiTest(rqueue, ctrl)
+
        req := requestsTests[0].req
        empty := AccessInfo{}
+       testErr := errors.New("Test Error")
 
        // Add valid request.
        reqid, err := rqueue.NewRequest(req.Caps, req.Priority, req.Owner, req.ValidAfter, req.Deadline)
@@ -489,18 +494,35 @@ func TestAcquireWorker(t *testing.T) {
        assert.Equal(NotFoundError("Request"), err)
        assert.Equal(empty, ainfo)
 
+       // Try to acquire worker when jobs.Get() fails.
+       jobInfo := JobInfo{
+               WorkerUUID: "Test WorkerUUID",
+       }
+       rqueue.mutex.Lock()
+       rqueue.requests[reqid].Job = &jobInfo
+       rqueue.mutex.Unlock()
+       ignoredJob := &workers.Job{Req: ReqID(0xBAD)}
+       jm.EXPECT().Get(jobInfo.WorkerUUID).Return(ignoredJob, testErr)
+       ainfo, err = rqueue.AcquireWorker(reqid)
+       assert.Equal(testErr, err)
+       assert.Equal(empty, ainfo)
+
        // AcquireWorker to succeed needs JobInfo to be set. It also needs to be
        // in INPROGRESS state, which was set in the loop.
+       job := &workers.Job{
+               Access: AccessInfo{Addr: &net.TCPAddr{IP: net.IPv4(1, 2, 3, 4)}},
+       }
        rqueue.mutex.Lock()
-       rqueue.requests[reqid].Job = new(JobInfo)
+       rqueue.requests[reqid].Job = &jobInfo
        rqueue.mutex.Unlock()
+       jm.EXPECT().Get(jobInfo.WorkerUUID).Return(job, nil)
        ainfo, err = rqueue.AcquireWorker(reqid)
        assert.Nil(err)
-       assert.Equal(empty, ainfo)
+       assert.Equal(job.Access, ainfo)
 }
 
 func TestProlongAccess(t *testing.T) {
-       assert, rqueue, ctrl := initTest(t)
+       assert, rqueue, ctrl, _ := initTest(t)
        defer finiTest(rqueue, ctrl)
        req := requestsTests[0].req