diff --git a/internal/worker/client.go b/internal/worker/client.go new file mode 100644 index 00000000..8507f57c --- /dev/null +++ b/internal/worker/client.go @@ -0,0 +1,33 @@ +package worker + +/* ***** BEGIN GPL LICENSE BLOCK ***** + * + * Original Code Copyright (C) 2022 Blender Foundation. + * + * This file is part of Flamenco. + * + * Flamenco is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation, either version 3 of the License, or (at your option) any later + * version. + * + * Flamenco is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with + * Flamenco. If not, see . + * + * ***** END GPL LICENSE BLOCK ***** */ + +import ( + "gitlab.com/blender/flamenco-ng-poc/pkg/api" +) + +// Generate the mock for the client interface. +//go:generate go run github.com/golang/mock/mockgen -destination mocks/client.gen.go -package mocks gitlab.com/blender/flamenco-ng-poc/internal/worker FlamencoClient + +// FlamencoClient is a wrapper for api.ClientWithResponsesInterface so that locally mocks can be created. +type FlamencoClient interface { + api.ClientWithResponsesInterface +} diff --git a/internal/worker/listener.go b/internal/worker/listener.go index 0e307273..99467c9a 100644 --- a/internal/worker/listener.go +++ b/internal/worker/listener.go @@ -43,11 +43,11 @@ var ( // Listener listens to the result of task and command execution, and sends it to the Manager. type Listener struct { doneWg *sync.WaitGroup - client api.ClientWithResponsesInterface + client FlamencoClient } // NewListener creates a new Listener that will send updates to the API client. -func NewListener(client api.ClientWithResponsesInterface) *Listener { +func NewListener(client FlamencoClient) *Listener { l := &Listener{ doneWg: new(sync.WaitGroup), client: client, diff --git a/internal/worker/mocks/client.gen.go b/internal/worker/mocks/client.gen.go new file mode 100644 index 00000000..65253bce --- /dev/null +++ b/internal/worker/mocks/client.gen.go @@ -0,0 +1,337 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: gitlab.com/blender/flamenco-ng-poc/internal/worker (interfaces: FlamencoClient) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + io "io" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + api "gitlab.com/blender/flamenco-ng-poc/pkg/api" +) + +// MockFlamencoClient is a mock of FlamencoClient interface. +type MockFlamencoClient struct { + ctrl *gomock.Controller + recorder *MockFlamencoClientMockRecorder +} + +// MockFlamencoClientMockRecorder is the mock recorder for MockFlamencoClient. +type MockFlamencoClientMockRecorder struct { + mock *MockFlamencoClient +} + +// NewMockFlamencoClient creates a new mock instance. +func NewMockFlamencoClient(ctrl *gomock.Controller) *MockFlamencoClient { + mock := &MockFlamencoClient{ctrl: ctrl} + mock.recorder = &MockFlamencoClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockFlamencoClient) EXPECT() *MockFlamencoClientMockRecorder { + return m.recorder +} + +// FetchJobWithResponse mocks base method. +func (m *MockFlamencoClient) FetchJobWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchJobResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FetchJobWithResponse", varargs...) + ret0, _ := ret[0].(*api.FetchJobResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchJobWithResponse indicates an expected call of FetchJobWithResponse. +func (mr *MockFlamencoClientMockRecorder) FetchJobWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchJobWithResponse), varargs...) +} + +// GetJobTypesWithResponse mocks base method. +func (m *MockFlamencoClient) GetJobTypesWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetJobTypesResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetJobTypesWithResponse", varargs...) + ret0, _ := ret[0].(*api.GetJobTypesResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetJobTypesWithResponse indicates an expected call of GetJobTypesWithResponse. +func (mr *MockFlamencoClientMockRecorder) GetJobTypesWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobTypesWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetJobTypesWithResponse), varargs...) +} + +// RegisterWorkerWithBodyWithResponse mocks base method. +func (m *MockFlamencoClient) RegisterWorkerWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.RegisterWorkerResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterWorkerWithBodyWithResponse", varargs...) + ret0, _ := ret[0].(*api.RegisterWorkerResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterWorkerWithBodyWithResponse indicates an expected call of RegisterWorkerWithBodyWithResponse. +func (mr *MockFlamencoClientMockRecorder) RegisterWorkerWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkerWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RegisterWorkerWithBodyWithResponse), varargs...) +} + +// RegisterWorkerWithResponse mocks base method. +func (m *MockFlamencoClient) RegisterWorkerWithResponse(arg0 context.Context, arg1 api.RegisterWorkerJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.RegisterWorkerResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterWorkerWithResponse", varargs...) + ret0, _ := ret[0].(*api.RegisterWorkerResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterWorkerWithResponse indicates an expected call of RegisterWorkerWithResponse. +func (mr *MockFlamencoClientMockRecorder) RegisterWorkerWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkerWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RegisterWorkerWithResponse), varargs...) +} + +// ScheduleTaskWithResponse mocks base method. +func (m *MockFlamencoClient) ScheduleTaskWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.ScheduleTaskResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ScheduleTaskWithResponse", varargs...) + ret0, _ := ret[0].(*api.ScheduleTaskResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ScheduleTaskWithResponse indicates an expected call of ScheduleTaskWithResponse. +func (mr *MockFlamencoClientMockRecorder) ScheduleTaskWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleTaskWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ScheduleTaskWithResponse), varargs...) +} + +// SignOffWithResponse mocks base method. +func (m *MockFlamencoClient) SignOffWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.SignOffResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SignOffWithResponse", varargs...) + ret0, _ := ret[0].(*api.SignOffResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SignOffWithResponse indicates an expected call of SignOffWithResponse. +func (mr *MockFlamencoClientMockRecorder) SignOffWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOffWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOffWithResponse), varargs...) +} + +// SignOnWithBodyWithResponse mocks base method. +func (m *MockFlamencoClient) SignOnWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.SignOnResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SignOnWithBodyWithResponse", varargs...) + ret0, _ := ret[0].(*api.SignOnResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SignOnWithBodyWithResponse indicates an expected call of SignOnWithBodyWithResponse. +func (mr *MockFlamencoClientMockRecorder) SignOnWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOnWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOnWithBodyWithResponse), varargs...) +} + +// SignOnWithResponse mocks base method. +func (m *MockFlamencoClient) SignOnWithResponse(arg0 context.Context, arg1 api.SignOnJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.SignOnResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SignOnWithResponse", varargs...) + ret0, _ := ret[0].(*api.SignOnResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SignOnWithResponse indicates an expected call of SignOnWithResponse. +func (mr *MockFlamencoClientMockRecorder) SignOnWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOnWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOnWithResponse), varargs...) +} + +// SubmitJobWithBodyWithResponse mocks base method. +func (m *MockFlamencoClient) SubmitJobWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.SubmitJobResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SubmitJobWithBodyWithResponse", varargs...) + ret0, _ := ret[0].(*api.SubmitJobResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubmitJobWithBodyWithResponse indicates an expected call of SubmitJobWithBodyWithResponse. +func (mr *MockFlamencoClientMockRecorder) SubmitJobWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitJobWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SubmitJobWithBodyWithResponse), varargs...) +} + +// SubmitJobWithResponse mocks base method. +func (m *MockFlamencoClient) SubmitJobWithResponse(arg0 context.Context, arg1 api.SubmitJobJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.SubmitJobResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SubmitJobWithResponse", varargs...) + ret0, _ := ret[0].(*api.SubmitJobResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubmitJobWithResponse indicates an expected call of SubmitJobWithResponse. +func (mr *MockFlamencoClientMockRecorder) SubmitJobWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitJobWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SubmitJobWithResponse), varargs...) +} + +// TaskUpdateWithBodyWithResponse mocks base method. +func (m *MockFlamencoClient) TaskUpdateWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.TaskUpdateResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2, arg3} + for _, a := range arg4 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TaskUpdateWithBodyWithResponse", varargs...) + ret0, _ := ret[0].(*api.TaskUpdateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TaskUpdateWithBodyWithResponse indicates an expected call of TaskUpdateWithBodyWithResponse. +func (mr *MockFlamencoClientMockRecorder) TaskUpdateWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskUpdateWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).TaskUpdateWithBodyWithResponse), varargs...) +} + +// TaskUpdateWithResponse mocks base method. +func (m *MockFlamencoClient) TaskUpdateWithResponse(arg0 context.Context, arg1 string, arg2 api.TaskUpdateJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.TaskUpdateResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TaskUpdateWithResponse", varargs...) + ret0, _ := ret[0].(*api.TaskUpdateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TaskUpdateWithResponse indicates an expected call of TaskUpdateWithResponse. +func (mr *MockFlamencoClientMockRecorder) TaskUpdateWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskUpdateWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).TaskUpdateWithResponse), varargs...) +} + +// WorkerStateChangedWithBodyWithResponse mocks base method. +func (m *MockFlamencoClient) WorkerStateChangedWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.WorkerStateChangedResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WorkerStateChangedWithBodyWithResponse", varargs...) + ret0, _ := ret[0].(*api.WorkerStateChangedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// WorkerStateChangedWithBodyWithResponse indicates an expected call of WorkerStateChangedWithBodyWithResponse. +func (mr *MockFlamencoClientMockRecorder) WorkerStateChangedWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateChangedWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateChangedWithBodyWithResponse), varargs...) +} + +// WorkerStateChangedWithResponse mocks base method. +func (m *MockFlamencoClient) WorkerStateChangedWithResponse(arg0 context.Context, arg1 api.WorkerStateChangedJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.WorkerStateChangedResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WorkerStateChangedWithResponse", varargs...) + ret0, _ := ret[0].(*api.WorkerStateChangedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// WorkerStateChangedWithResponse indicates an expected call of WorkerStateChangedWithResponse. +func (mr *MockFlamencoClientMockRecorder) WorkerStateChangedWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateChangedWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateChangedWithResponse), varargs...) +} + +// WorkerStateWithResponse mocks base method. +func (m *MockFlamencoClient) WorkerStateWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.WorkerStateResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WorkerStateWithResponse", varargs...) + ret0, _ := ret[0].(*api.WorkerStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// WorkerStateWithResponse indicates an expected call of WorkerStateWithResponse. +func (mr *MockFlamencoClientMockRecorder) WorkerStateWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateWithResponse), varargs...) +} diff --git a/internal/worker/registration.go b/internal/worker/registration.go index b39a662e..18bde96f 100644 --- a/internal/worker/registration.go +++ b/internal/worker/registration.go @@ -44,7 +44,7 @@ var ( // registerOrSignOn tries to sign on, and if that fails (or there are no credentials) tries to register. // Returns an authenticated Flamenco OpenAPI client. func RegisterOrSignOn(ctx context.Context, configWrangler FileConfigWrangler) ( - client api.ClientWithResponsesInterface, startupState api.WorkerStatus, + client FlamencoClient, startupState api.WorkerStatus, ) { // Load configuration cfg, err := loadConfig(configWrangler) @@ -93,7 +93,7 @@ func RegisterOrSignOn(ctx context.Context, configWrangler FileConfigWrangler) ( // (Re-)register ourselves at the Manager. // Logs a fatal error if unsuccesful. -func register(ctx context.Context, cfg WorkerConfig, client api.ClientWithResponsesInterface) WorkerCredentials { +func register(ctx context.Context, cfg WorkerConfig, client FlamencoClient) WorkerCredentials { // Construct our new password. secret := make([]byte, 32) if _, err := rand.Read(secret); err != nil { @@ -132,7 +132,7 @@ func register(ctx context.Context, cfg WorkerConfig, client api.ClientWithRespon // repeatSignOnUntilAnswer tries to sign on, and only returns when it has been able to reach the Manager. // Return still doesn't mean that the sign-on was succesful; inspect the returned error. -func repeatSignOnUntilAnswer(ctx context.Context, cfg WorkerConfig, client api.ClientWithResponsesInterface) (api.WorkerStatus, error) { +func repeatSignOnUntilAnswer(ctx context.Context, cfg WorkerConfig, client FlamencoClient) (api.WorkerStatus, error) { waitTime := 0 * time.Second for { select { @@ -157,7 +157,7 @@ func repeatSignOnUntilAnswer(ctx context.Context, cfg WorkerConfig, client api.C } // signOn tells the Manager we're alive and returns the status the Manager tells us to go to. -func signOn(ctx context.Context, cfg WorkerConfig, client api.ClientWithResponsesInterface) (api.WorkerStatus, error) { +func signOn(ctx context.Context, cfg WorkerConfig, client FlamencoClient) (api.WorkerStatus, error) { logger := log.With().Str("manager", cfg.Manager).Logger() req := api.SignOnJSONRequestBody{ @@ -206,7 +206,7 @@ func mustHostname() string { } // authenticatedClient constructs a Flamenco client with the given credentials. -func authenticatedClient(cfg WorkerConfig, creds WorkerCredentials) api.ClientWithResponsesInterface { +func authenticatedClient(cfg WorkerConfig, creds WorkerCredentials) FlamencoClient { flamenco, err := api.NewClientWithResponses( cfg.Manager, diff --git a/internal/worker/worker.go b/internal/worker/worker.go index c102d231..cdefaca0 100644 --- a/internal/worker/worker.go +++ b/internal/worker/worker.go @@ -13,7 +13,7 @@ type Worker struct { doneChan chan struct{} doneWg *sync.WaitGroup - client api.ClientWithResponsesInterface + client FlamencoClient state api.WorkerStatus stateStarters map[api.WorkerStatus]StateStarter // gotoStateXXX functions @@ -30,7 +30,7 @@ type TaskRunner interface { // NewWorker constructs and returns a new Worker. func NewWorker( - flamenco api.ClientWithResponsesInterface, + flamenco FlamencoClient, taskRunner TaskRunner, ) *Worker {