Implement UpdateRequest

Change-Id: Ibad4fab53af38f0be6794c1c16394c4bc06dafc9
Signed-off-by: Maciej Wereski <m.wereski@partner.samsung.com>
Reviewed-on: https://mcdsrvbld02.digital.local/review/49546
Reviewed-by: Aleksander Mistewicz <a.mistewicz@samsung.com>
Tested-by: Aleksander Mistewicz <a.mistewicz@samsung.com>

diff --git a/requests/requests.go b/requests/requests.go
index 8561792..3f8d9a2 100644 (file)
--- a/requests/requests.go
+++ b/requests/requests.go
@@ -121,78 +121,57 @@ func modificationPossible(state ReqState) bool {
        return state == WAIT
 }
 
-// SetRequestPriority is part of implementation of Requests interface. It will
-// change priority for given request ID only if modification of request is
-// possible. NotFoundError, ErrModificationForbidden or ErrPriority (if given
-// priority is out of bounds) may be returned.
-func (reqs *ReqsCollection) SetRequestPriority(reqID ReqID, priority Priority) error {
+// UpdateRequest is part of implementation of Requests interface. It may be used
+// to modify ValidAfter, Deadline or Priority of request. Caller should pass
+// pointer to new ReqInfo struct which has any of these fields set. Zero value
+// means that field shouldn't be changed. All fields that cannot be changed are
+// ignored.
+func (reqs *ReqsCollection) UpdateRequest(src *ReqInfo) error {
+       if src == nil || (src.Priority == Priority(0) &&
+               src.ValidAfter.IsZero() &&
+               src.Deadline.IsZero()) {
+               return nil
+       }
        reqs.mutex.Lock()
        defer reqs.mutex.Unlock()
-       req, ok := reqs.requests[reqID]
+
+       dst, ok := reqs.requests[src.ID]
        if !ok {
                return NotFoundError("Request")
        }
-       // TODO(mwereski): Check if user has rights to set given priority.
-       if priority < HiPrio || priority > LoPrio {
-               return ErrPriority
-       }
-       if !modificationPossible(req.State) {
+       if !modificationPossible(dst.State) {
                return ErrModificationForbidden
        }
-       if priority == req.Priority {
+       if src.Priority == dst.Priority &&
+               src.ValidAfter.Equal(dst.ValidAfter) &&
+               src.Deadline.Equal(dst.Deadline) {
                return nil
        }
-       reqs.queue.setRequestPriority(req, priority)
-       req.Priority = priority
-       return nil
-}
-
-// SetRequestValidAfter is part of implementation of Requests interface.
-// It changes date after which request will be sent to worker. Provided time is
-// converted to UTC. Request must exist, must be in WAIT state and given date
-// must be before deadline of request. Otherwise NotFoundError,
-// ErrModificationForbidden or ErrInvalidTimeRange will be returned.
-func (reqs *ReqsCollection) SetRequestValidAfter(reqID ReqID, validAfter time.Time) error {
-       reqs.mutex.Lock()
-       defer reqs.mutex.Unlock()
-       req, ok := reqs.requests[reqID]
-       if !ok {
-               return NotFoundError("Request")
+       // TODO(mwereski): Check if user has rights to set given priority.
+       if src.Priority != Priority(0) && (src.Priority < HiPrio ||
+               src.Priority > LoPrio) {
+               return ErrPriority
        }
-       if !modificationPossible(req.State) {
-               return ErrModificationForbidden
+       deadline := dst.Deadline
+       if !src.Deadline.IsZero() {
+               if src.Deadline.Before(time.Now().UTC()) {
+                       return ErrDeadlineInThePast
+               }
+               deadline = src.Deadline
        }
-       if validAfter.After(req.Deadline) && !req.Deadline.IsZero() {
+       if (!src.ValidAfter.IsZero()) && !deadline.IsZero() &&
+               src.ValidAfter.After(deadline) {
                return ErrInvalidTimeRange
        }
-       req.ValidAfter = validAfter
-       // TODO(mwereski): check if request is ready to go.
-       return nil
-}
 
-// SetRequestDeadline is part of implementation of Requests interface. It changes
-// date before which request must be sent to worker. Provided time is converted
-// to UTC. Request must exist, must be in WAIT state. Given date must be in the
-// future and must be after ValidAfer. In case of not meeting these constrains
-// following errors are returned: NotFoundError, ErrModificationForbidden,
-// ErrDeadlineInThePast and ErrInvalidTimeRange.
-func (reqs *ReqsCollection) SetRequestDeadline(reqID ReqID, deadline time.Time) error {
-       reqs.mutex.Lock()
-       defer reqs.mutex.Unlock()
-       req, ok := reqs.requests[reqID]
-       if !ok {
-               return NotFoundError("Request")
+       if src.Priority != Priority(0) {
+               reqs.queue.setRequestPriority(dst, src.Priority)
+               dst.Priority = src.Priority
        }
-       if !modificationPossible(req.State) {
-               return ErrModificationForbidden
-       }
-       if !deadline.IsZero() && deadline.Before(time.Now().UTC()) {
-               return ErrDeadlineInThePast
-       }
-       if !deadline.IsZero() && deadline.Before(req.ValidAfter) {
-               return ErrInvalidTimeRange
+       if !src.ValidAfter.IsZero() {
+               dst.ValidAfter = src.ValidAfter
        }
-       req.Deadline = deadline
+       dst.Deadline = deadline
        // TODO(mwereski): check if request is ready to go.
        return nil
 }

diff --git a/requests/requests_test.go b/requests/requests_test.go
index 368a869..64b6afe 100644 (file)
--- a/requests/requests_test.go
+++ b/requests/requests_test.go
@@ -151,109 +151,83 @@ func TestCloseRequest(t *testing.T) {
        assert.EqualValues(0, rqueue.queue.length)
 }
 
-func TestSetRequestPriority(t *testing.T) {
+func TestUpdateRequest(t *testing.T) {
        assert, rqueue := initTest(t)
-       req := requestsTests[0].req
+       tmp := requestsTests[0].req
 
        // Add valid request.
-       reqid, err := rqueue.NewRequest(req.Caps, req.Priority, req.Owner, req.ValidAfter, req.Deadline)
-       assert.Nil(err)
-
-       legalPrio := req.Priority + 1
-       illegalPrio := 2 * LoPrio
-
-       // Change priority of the request to the same value.
-       err = rqueue.SetRequestPriority(reqid, req.Priority)
+       reqid, err := rqueue.NewRequest(tmp.Caps, tmp.Priority, tmp.Owner, tmp.ValidAfter, tmp.Deadline)
        assert.Nil(err)
-       reqinfo, err := rqueue.GetRequestInfo(reqid)
+       req := rqueue.requests[reqid]
+       reqBefore, err := rqueue.GetRequestInfo(reqid)
        assert.Nil(err)
-       assert.Equal(req.Priority, reqinfo.Priority)
+       reqUpdate := new(ReqInfo)
+       *reqUpdate = *req
 
-       // Change priority of the request.
-       err = rqueue.SetRequestPriority(reqid, legalPrio)
+       // Check noop.
+       err = rqueue.UpdateRequest(nil)
        assert.Nil(err)
-       reqinfo, err = rqueue.GetRequestInfo(reqid)
+       reqUpdate.ValidAfter = zeroTime
+       reqUpdate.Deadline = zeroTime
+       reqUpdate.Priority = Priority(0)
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Nil(err)
-       assert.Equal(legalPrio, reqinfo.Priority)
-
-       // Try to change priority of request that doesn't exist.
-       err = rqueue.SetRequestPriority(req.ID+1, legalPrio)
+       assert.Equal(req, &reqBefore)
+       // Check request that doesn't exist.
+       *reqUpdate = *req
+       reqUpdate.ID++
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Equal(NotFoundError("Request"), err)
-       reqinfo, err = rqueue.GetRequestInfo(reqid)
+       reqUpdate.ID = req.ID
+       // Change Priority only.
+       reqUpdate.Priority = req.Priority - 1
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Nil(err)
-       assert.Equal(legalPrio, reqinfo.Priority)
-
-       // Try to change priority of request to invalid value.
-       err = rqueue.SetRequestPriority(reqid, illegalPrio)
-       assert.Equal(ErrPriority, err)
-       reqinfo, err = rqueue.GetRequestInfo(reqid)
+       assert.Equal(reqUpdate.Priority, req.Priority)
+       // Change ValidAfter only.
+       reqUpdate.ValidAfter = yesterday
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Nil(err)
-       assert.Equal(legalPrio, reqinfo.Priority)
-
-       // Try to change priority of request which is in state that forbid changes.
-       rqueue.requests[reqid].State = INVALID
-       err = rqueue.SetRequestPriority(reqid, legalPrio)
-       assert.EqualValues(ErrModificationForbidden, err)
-       reqinfo, err = rqueue.GetRequestInfo(reqid)
+       assert.Equal(reqUpdate.ValidAfter, req.ValidAfter)
+       // Change Deadline only.
+       reqUpdate.Deadline = tomorrow.AddDate(0, 0, 1).UTC()
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Nil(err)
-       assert.Equal(legalPrio, reqinfo.Priority)
-}
-
-func TestSetRequestValidAfter(t *testing.T) {
-       assert, rqueue := initTest(t)
-       req := requestsTests[0].req
-       reqid, err := rqueue.NewRequest(req.Caps, req.Priority, req.Owner, req.ValidAfter, req.Deadline)
+       assert.Equal(reqUpdate.Deadline, req.Deadline)
+       // Change Priority, ValidAfter and Deadline.
+       reqUpdate.Deadline = tomorrow
+       reqUpdate.ValidAfter = time.Now().Add(time.Hour)
+       reqUpdate.Priority = LoPrio
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Nil(err)
-
-       // Set legal ValidAfter value.
-       err = rqueue.SetRequestValidAfter(reqid, tomorrow)
+       assert.Equal(reqUpdate, req)
+       // Change values to the same ones that are already set.
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Nil(err)
-       assert.Equal(tomorrow, rqueue.requests[reqid].ValidAfter)
-
-       // Try to set ValidAfter for non-existent request.
-       err = rqueue.SetRequestValidAfter(ReqID(2), tomorrow)
-       assert.Equal(NotFoundError("Request"), err)
-
-       // Try to set ValidAfter newer then Deadline.
-       rqueue.requests[reqid].Deadline = now
-       err = rqueue.SetRequestValidAfter(reqid, tomorrow)
-       assert.Equal(ErrInvalidTimeRange, err)
-
-       // Try to set ValidAfter for request which cannot be modified.
-       rqueue.requests[reqid].State = INVALID
-       err = rqueue.SetRequestValidAfter(reqid, yesterday)
-       assert.EqualValues(ErrModificationForbidden, err)
-}
-
-func TestSetRequestDeadline(t *testing.T) {
-       assert, rqueue := initTest(t)
-       req := requestsTests[0].req
-       reqid, err := rqueue.NewRequest(req.Caps, req.Priority, req.Owner, req.ValidAfter, req.Deadline)
-       assert.Nil(err)
-
-       // Set legal Deadline value.
-       dayAfter := tomorrow.AddDate(0, 0, 1).UTC()
-       err = rqueue.SetRequestDeadline(reqid, dayAfter)
-       assert.Nil(err)
-       assert.Equal(dayAfter, rqueue.requests[reqid].Deadline)
-
-       // Try to set Deadline for non-existent request.
-       err = rqueue.SetRequestDeadline(ReqID(2), tomorrow)
-       assert.Equal(NotFoundError("Request"), err)
-
-       // Try to set Deadline in the past.
-       err = rqueue.SetRequestDeadline(reqid, yesterday)
+       assert.Equal(reqUpdate, req)
+       // Change Priority to illegal value.
+       reqUpdate.Priority = LoPrio + 1
+       err = rqueue.UpdateRequest(reqUpdate)
+       assert.Equal(ErrPriority, err)
+       reqUpdate.Priority = req.Priority
+       //Change Deadline to illegal value.
+       reqUpdate.Deadline = yesterday
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Equal(ErrDeadlineInThePast, err)
-
-       // Try to set Deadline before ValidAfter.
-       rqueue.requests[reqid].ValidAfter = dayAfter
-       err = rqueue.SetRequestDeadline(reqid, tomorrow)
+       reqUpdate.Deadline = time.Now().Add(time.Minute)
+       err = rqueue.UpdateRequest(reqUpdate)
        assert.Equal(ErrInvalidTimeRange, err)
-
-       // Try to set Deadline for request which cannot be modified.
-       rqueue.requests[reqid].State = INVALID
-       err = rqueue.SetRequestDeadline(reqid, tomorrow)
-       assert.EqualValues(ErrModificationForbidden, err)
+       // Change ValidAfer to illegal value.
+       reqUpdate.ValidAfter = req.Deadline.Add(time.Hour)
+       err = rqueue.UpdateRequest(reqUpdate)
+       assert.Equal(ErrInvalidTimeRange, err)
+       // Try to change values for other changes.
+       states := [...]ReqState{INVALID, CANCEL, TIMEOUT, DONE, FAILED, INPROGRESS}
+       for _, state := range states {
+               rqueue.requests[reqid].State = state
+               err = rqueue.UpdateRequest(reqUpdate)
+               assert.Equal(ErrModificationForbidden, err)
+       }
 }
 
 func TestGetRequestInfo(t *testing.T) {