blender/flamenco
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor: rename RequeueTasksOfWorker to RequeueActiveTasksOfWorker

Browse Source 
Soon there will be another function to requeue tasks of workers by other
criteria, so being clear in the name helps.

No functional changes.
This commit is contained in:
Sybren A. Stüvel 2022-06-17 15:21:23 +02:00
parent fd31a85bcd
commit b95bed1f96
10 changed files with 23 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
internal/manager/api_impl/interfaces.go
View File

@ -74,7 +74,7 @@ type TaskStateMachine interface {
// JobStatusChange gives a Job a new status, and handles the resulting status changes on its tasks. // JobStatusChange gives a Job a new status, and handles the resulting status changes on its tasks.
JobStatusChange(ctx context.Context, job *persistence.Job, newJobStatus api.JobStatus, reason string) error JobStatusChange(ctx context.Context, job *persistence.Job, newJobStatus api.JobStatus, reason string) error
RequeueTasksOfWorker(ctx context.Context, worker *persistence.Worker, reason string) error RequeueActiveTasksOfWorker(ctx context.Context, worker *persistence.Worker, reason string) error
} }
// TaskStateMachine should be a subset of task_state_machine.StateMachine. // TaskStateMachine should be a subset of task_state_machine.StateMachine.

12
internal/manager/api_impl/mocks/api_impl_mock.gen.go
View File

@ -665,18 +665,18 @@ func (mr *MockTaskStateMachineMockRecorder) JobStatusChange(arg0, arg1, arg2, ar
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JobStatusChange", reflect.TypeOf((*MockTaskStateMachine)(nil).JobStatusChange), arg0, arg1, arg2, arg3) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JobStatusChange", reflect.TypeOf((*MockTaskStateMachine)(nil).JobStatusChange), arg0, arg1, arg2, arg3)
} }
// RequeueTasksOfWorker mocks base method. // RequeueActiveTasksOfWorker mocks base method.
func (m *MockTaskStateMachine) RequeueTasksOfWorker(arg0 context.Context, arg1 *persistence.Worker, arg2 string) error { func (m *MockTaskStateMachine) RequeueActiveTasksOfWorker(arg0 context.Context, arg1 *persistence.Worker, arg2 string) error {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RequeueTasksOfWorker", arg0, arg1, arg2) ret := m.ctrl.Call(m, "RequeueActiveTasksOfWorker", arg0, arg1, arg2)
ret0, _ := ret[0].(error) ret0, _ := ret[0].(error)
return ret0 return ret0
} }
// RequeueTasksOfWorker indicates an expected call of RequeueTasksOfWorker. // RequeueActiveTasksOfWorker indicates an expected call of RequeueActiveTasksOfWorker.
func (mr *MockTaskStateMachineMockRecorder) RequeueTasksOfWorker(arg0, arg1, arg2 interface{}) *gomock.Call { func (mr *MockTaskStateMachineMockRecorder) RequeueActiveTasksOfWorker(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequeueTasksOfWorker", reflect.TypeOf((*MockTaskStateMachine)(nil).RequeueTasksOfWorker), arg0, arg1, arg2) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequeueActiveTasksOfWorker", reflect.TypeOf((*MockTaskStateMachine)(nil).RequeueActiveTasksOfWorker), arg0, arg1, arg2)
} }
// TaskStatusChange mocks base method. // TaskStatusChange mocks base method.

2
internal/manager/api_impl/workers.go
View File

@ -177,7 +177,7 @@ func (f *Flamenco) SignOff(e echo.Context) error {
_ = f.workerSeen(ctx, logger, w) _ = f.workerSeen(ctx, logger, w)
// Re-queue all tasks (should be only one) this worker is now working on. // Re-queue all tasks (should be only one) this worker is now working on.
err = f.stateMachine.RequeueTasksOfWorker(ctx, w, "worker signed off") err = f.stateMachine.RequeueActiveTasksOfWorker(ctx, w, "worker signed off")
if err != nil { if err != nil {
return sendAPIError(e, http.StatusInternalServerError, "error re-queueing your tasks") return sendAPIError(e, http.StatusInternalServerError, "error re-queueing your tasks")
} }

4
internal/manager/api_impl/workers_test.go
View File

@ -199,7 +199,7 @@ func TestWorkerSignoffTaskRequeue(t *testing.T) {
expectCtx := gomock.Not(gomock.Eq(echo.Request().Context())) expectCtx := gomock.Not(gomock.Eq(echo.Request().Context()))
// Expect worker's tasks to be re-queued. // Expect worker's tasks to be re-queued.
mf.stateMachine.EXPECT().RequeueTasksOfWorker(expectCtx, &worker, "worker signed off").Return(nil) mf.stateMachine.EXPECT().RequeueActiveTasksOfWorker(expectCtx, &worker, "worker signed off").Return(nil)
mf.persistence.EXPECT().WorkerSeen(expectCtx, &worker) mf.persistence.EXPECT().WorkerSeen(expectCtx, &worker)
// Expect worker to be saved as 'offline'. // Expect worker to be saved as 'offline'.
@ -251,7 +251,7 @@ func TestWorkerSignoffStatusChangeRequest(t *testing.T) {
savedWorker.StatusChangeClear() savedWorker.StatusChangeClear()
mf.persistence.EXPECT().SaveWorkerStatus(gomock.Any(), &savedWorker).Return(nil) mf.persistence.EXPECT().SaveWorkerStatus(gomock.Any(), &savedWorker).Return(nil)
mf.stateMachine.EXPECT().RequeueTasksOfWorker(gomock.Any(), &worker, "worker signed off").Return(nil) mf.stateMachine.EXPECT().RequeueActiveTasksOfWorker(gomock.Any(), &worker, "worker signed off").Return(nil)
mf.persistence.EXPECT().WorkerSeen(gomock.Any(), &worker) mf.persistence.EXPECT().WorkerSeen(gomock.Any(), &worker)
// Perform the request // Perform the request

4
internal/manager/task_state_machine/worker_requeue.go
View File

@ -11,10 +11,10 @@ import (
"github.com/rs/zerolog/log" "github.com/rs/zerolog/log"
) )
// RequeueTasksOfWorker re-queues all active tasks (should be max one) of this worker. // RequeueActiveTasksOfWorker re-queues all active tasks (should be max one) of this worker.
// //
// `reason`: a string that can be appended to text like "Task requeued because " // `reason`: a string that can be appended to text like "Task requeued because "
func (sm *StateMachine) RequeueTasksOfWorker( func (sm *StateMachine) RequeueActiveTasksOfWorker(
ctx context.Context, ctx context.Context,
worker *persistence.Worker, worker *persistence.Worker,
reason string, reason string,

4
internal/manager/task_state_machine/worker_requeue_test.go
View File

@ -9,7 +9,7 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
func TestRequeueTasksOfWorker(t *testing.T) { func TestRequeueActiveTasksOfWorker(t *testing.T) {
mockCtrl, ctx, sm, mocks := taskStateMachineTestFixtures(t) mockCtrl, ctx, sm, mocks := taskStateMachineTestFixtures(t)
defer mockCtrl.Finish() defer mockCtrl.Finish()
@ -59,6 +59,6 @@ func TestRequeueTasksOfWorker(t *testing.T) {
Updated: task2.UpdatedAt, Updated: task2.UpdatedAt,
}) })
err := sm.RequeueTasksOfWorker(ctx, &worker, "worker had to test") err := sm.RequeueActiveTasksOfWorker(ctx, &worker, "worker had to test")
assert.NoError(t, err) assert.NoError(t, err)
} }

2
internal/manager/timeout_checker/interfaces.go
View File

@ -27,7 +27,7 @@ var _ PersistenceService = (*persistence.DB)(nil)
type TaskStateMachine interface { type TaskStateMachine interface {
// TaskStatusChange gives a Task a new status, and handles the resulting status changes on the job. // TaskStatusChange gives a Task a new status, and handles the resulting status changes on the job.
TaskStatusChange(ctx context.Context, task *persistence.Task, newStatus api.TaskStatus) error TaskStatusChange(ctx context.Context, task *persistence.Task, newStatus api.TaskStatus) error
RequeueTasksOfWorker(ctx context.Context, worker *persistence.Worker, reason string) error RequeueActiveTasksOfWorker(ctx context.Context, worker *persistence.Worker, reason string) error
} }
var _ TaskStateMachine = (*task_state_machine.StateMachine)(nil) var _ TaskStateMachine = (*task_state_machine.StateMachine)(nil)

12
internal/manager/timeout_checker/mocks/interfaces_mock.gen.go
View File

@ -105,18 +105,18 @@ func (m *MockTaskStateMachine) EXPECT() *MockTaskStateMachineMockRecorder {
return m.recorder return m.recorder
} }
// RequeueTasksOfWorker mocks base method. // RequeueActiveTasksOfWorker mocks base method.
func (m *MockTaskStateMachine) RequeueTasksOfWorker(arg0 context.Context, arg1 *persistence.Worker, arg2 string) error { func (m *MockTaskStateMachine) RequeueActiveTasksOfWorker(arg0 context.Context, arg1 *persistence.Worker, arg2 string) error {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RequeueTasksOfWorker", arg0, arg1, arg2) ret := m.ctrl.Call(m, "RequeueActiveTasksOfWorker", arg0, arg1, arg2)
ret0, _ := ret[0].(error) ret0, _ := ret[0].(error)
return ret0 return ret0
} }
// RequeueTasksOfWorker indicates an expected call of RequeueTasksOfWorker. // RequeueActiveTasksOfWorker indicates an expected call of RequeueActiveTasksOfWorker.
func (mr *MockTaskStateMachineMockRecorder) RequeueTasksOfWorker(arg0, arg1, arg2 interface{}) *gomock.Call { func (mr *MockTaskStateMachineMockRecorder) RequeueActiveTasksOfWorker(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequeueTasksOfWorker", reflect.TypeOf((*MockTaskStateMachine)(nil).RequeueTasksOfWorker), arg0, arg1, arg2) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequeueActiveTasksOfWorker", reflect.TypeOf((*MockTaskStateMachine)(nil).RequeueActiveTasksOfWorker), arg0, arg1, arg2)
} }
// TaskStatusChange mocks base method. // TaskStatusChange mocks base method.

2
internal/manager/timeout_checker/workers.go
View File

@ -54,7 +54,7 @@ func (ttc *TimeoutChecker) timeoutWorker(ctx context.Context, worker *persistenc
logger.Error().Err(err).Msg("TimeoutChecker: error saving timed-out worker to database") logger.Error().Err(err).Msg("TimeoutChecker: error saving timed-out worker to database")
} }
err = ttc.taskStateMachine.RequeueTasksOfWorker(ctx, worker, "worker timed out") err = ttc.taskStateMachine.RequeueActiveTasksOfWorker(ctx, worker, "worker timed out")
if err != nil { if err != nil {
logger.Error().Err(err).Msg("TimeoutChecker: error re-queueing tasks of timed-out worker") logger.Error().Err(err).Msg("TimeoutChecker: error re-queueing tasks of timed-out worker")
} }

2
internal/manager/timeout_checker/workers_test.go
View File

@ -43,7 +43,7 @@ func TestWorkerTimeout(t *testing.T) {
Return([]*persistence.Worker{&worker}, nil) Return([]*persistence.Worker{&worker}, nil)
// Expect all tasks assigned to the worker to get requeued. // Expect all tasks assigned to the worker to get requeued.
mocks.taskStateMachine.EXPECT().RequeueTasksOfWorker(mocks.ctx, &worker, "worker timed out") mocks.taskStateMachine.EXPECT().RequeueActiveTasksOfWorker(mocks.ctx, &worker, "worker timed out")
persistedWorker := worker persistedWorker := worker
persistedWorker.Status = api.WorkerStatusError persistedWorker.Status = api.WorkerStatusError