diff --git a/.mockery.yaml b/.mockery.yaml index 719c4b2b..25e5682f 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -4,129 +4,152 @@ dir: "_mocks/{{.PackagePath}}" # https://github.com/vektra/mockery/commit/13fc60740a1eab3fc705fcc131a4b9a6eacfd0fe#diff-4bc8f03915f15ecf2cb9965592fcf933bb06986003613b5633a8dea7962c31a9R40 resolve-type-alias: false packages: - io: - config: - interfaces: - Reader: - opencsg.com/csghub-server/component: - config: - interfaces: - RepoComponent: - TagComponent: - AccountingComponent: - SpaceComponent: - SpaceResourceComponent: - RuntimeArchitectureComponent: - SensitiveComponent: - CodeComponent: - PromptComponent: - ModelComponent: - UserComponent: - GitHTTPComponent: - DiscussionComponent: - DatasetComponent: - CollectionComponent: - InternalComponent: - MirrorSourceComponent: - MirrorComponent: - EvaluationComponent: + io: + config: + interfaces: + Reader: + opencsg.com/csghub-server/component: + config: + interfaces: + RepoComponent: + TagComponent: + AccountingComponent: + SpaceComponent: + SpaceResourceComponent: + RuntimeArchitectureComponent: + SensitiveComponent: + CodeComponent: + PromptComponent: + ModelComponent: + UserComponent: + GitHTTPComponent: + DiscussionComponent: + DatasetComponent: + CollectionComponent: + InternalComponent: + MirrorSourceComponent: + MirrorComponent: + ImportComponent: + EvaluationComponent: + RecomComponent: + MultiSyncComponent: + opencsg.com/csghub-server/component/callback: + config: + interfaces: + SyncVersionGenerator: + GitCallbackComponent: + opencsg.com/csghub-server/user/component: + config: + interfaces: + MemberComponent: + OrganizationComponent: - - opencsg.com/csghub-server/user/component: - config: - interfaces: - MemberComponent: - opencsg.com/csghub-server/builder/store/database: - config: - all: True - opencsg.com/csghub-server/builder/rpc: - config: - interfaces: - UserSvcClient: - ModerationSvcClient: - opencsg.com/csghub-server/builder/sensitive: - config: - interfaces: - GreenClient: - Green2022Client: - SensitiveChecker: - opencsg.com/csghub-server/builder/git/gitserver: - config: - interfaces: - GitServer: - opencsg.com/csghub-server/builder/git/mirrorserver: - config: - interfaces: - MirrorServer: - opencsg.com/csghub-server/builder/git/membership: - config: - interfaces: - GitMemerShip: - opencsg.com/csghub-server/builder/rsa: - config: - interfaces: - KeysReader: - opencsg.com/csghub-server/mirror/cache: - config: - interfaces: - Cache: - opencsg.com/csghub-server/common/types: - config: - interfaces: - SensitiveRequestV2: - opencsg.com/csghub-server/mq: - config: - interfaces: - MessageQueue: - opencsg.com/csghub-server/builder/store/s3: - config: - interfaces: - Client: - opencsg.com/csghub-server/mirror/queue: - config: - interfaces: - PriorityQueue: - opencsg.com/csghub-server/builder/deploy: - config: - interfaces: - Deployer: - opencsg.com/csghub-server/builder/deploy/scheduler: - config: - interfaces: - Scheduler: - opencsg.com/csghub-server/builder/deploy/imagerunner: - config: - interfaces: - Runner: - opencsg.com/csghub-server/builder/deploy/imagebuilder: - config: - interfaces: - Builder: - - opencsg.com/csghub-server/accounting/component: - config: - interfaces: - AccountingUserComponent: - AccountingStatementComponent: - AccountingBillComponent: - AccountingPresentComponent: - opencsg.com/csghub-server/builder/accounting: - config: - interfaces: - AccountingClient: - opencsg.com/csghub-server/builder/parquet: - config: - interfaces: - Reader: - opencsg.com/csghub-server/builder/multisync: - config: - interfaces: - Client: - github.com/nats-io/nats.go/jetstream: - config: - interfaces: - Msg: - go.temporal.io/sdk/client: - config: - interfaces: - Client: + opencsg.com/csghub-server/builder/store/database: + config: + all: True + opencsg.com/csghub-server/builder/rpc: + config: + interfaces: + UserSvcClient: + ModerationSvcClient: + opencsg.com/csghub-server/builder/sensitive: + config: + interfaces: + GreenClient: + Green2022Client: + SensitiveChecker: + opencsg.com/csghub-server/builder/git/gitserver: + config: + interfaces: + GitServer: + opencsg.com/csghub-server/builder/git/mirrorserver: + config: + interfaces: + MirrorServer: + opencsg.com/csghub-server/builder/git/membership: + config: + interfaces: + GitMemerShip: + opencsg.com/csghub-server/builder/rsa: + config: + interfaces: + KeysReader: + opencsg.com/csghub-server/mirror/cache: + config: + interfaces: + Cache: + opencsg.com/csghub-server/common/types: + config: + interfaces: + SensitiveRequestV2: + opencsg.com/csghub-server/mq: + config: + interfaces: + MessageQueue: + opencsg.com/csghub-server/builder/store/s3: + config: + interfaces: + Client: + opencsg.com/csghub-server/mirror/queue: + config: + interfaces: + PriorityQueue: + opencsg.com/csghub-server/builder/deploy: + config: + interfaces: + Deployer: + opencsg.com/csghub-server/builder/deploy/scheduler: + config: + interfaces: + Scheduler: + opencsg.com/csghub-server/builder/deploy/imagerunner: + config: + interfaces: + Runner: + opencsg.com/csghub-server/builder/deploy/imagebuilder: + config: + interfaces: + Builder: + opencsg.com/csghub-server/accounting/component: + config: + interfaces: + AccountingUserComponent: + AccountingStatementComponent: + AccountingBillComponent: + AccountingPresentComponent: + MeteringComponent: + AccountingEventComponent: + AccountingPriceComponent: + AccountingOrderComponent: + opencsg.com/csghub-server/builder/accounting: + config: + interfaces: + AccountingClient: + opencsg.com/csghub-server/builder/parquet: + config: + interfaces: + Reader: + opencsg.com/csghub-server/builder/multisync: + config: + interfaces: + Client: + opencsg.com/csghub-server/builder/store/cache: + config: + interfaces: + RedisClient: + github.com/nats-io/nats.go/jetstream: + config: + interfaces: + Msg: + go.temporal.io/sdk/client: + config: + interfaces: + Client: + opencsg.com/csghub-server/builder/temporal: + config: + interfaces: + Client: + opencsg.com/csghub-server/builder/importer: + config: + interfaces: + Importer: diff --git a/_mocks/go.temporal.io/sdk/client/mock_Client.go b/_mocks/go.temporal.io/sdk/client/mock_Client.go index 350bfeff..d44d8a24 100644 --- a/_mocks/go.temporal.io/sdk/client/mock_Client.go +++ b/_mocks/go.temporal.io/sdk/client/mock_Client.go @@ -1199,6 +1199,66 @@ func (_c *MockClient_ListWorkflow_Call) RunAndReturn(run func(context.Context, * return _c } +// NewWithStartWorkflowOperation provides a mock function with given fields: options, workflow, args +func (_m *MockClient) NewWithStartWorkflowOperation(options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) client.WithStartWorkflowOperation { + var _ca []interface{} + _ca = append(_ca, options, workflow) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for NewWithStartWorkflowOperation") + } + + var r0 client.WithStartWorkflowOperation + if rf, ok := ret.Get(0).(func(client.StartWorkflowOptions, interface{}, ...interface{}) client.WithStartWorkflowOperation); ok { + r0 = rf(options, workflow, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WithStartWorkflowOperation) + } + } + + return r0 +} + +// MockClient_NewWithStartWorkflowOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewWithStartWorkflowOperation' +type MockClient_NewWithStartWorkflowOperation_Call struct { + *mock.Call +} + +// NewWithStartWorkflowOperation is a helper method to define mock.On call +// - options client.StartWorkflowOptions +// - workflow interface{} +// - args ...interface{} +func (_e *MockClient_Expecter) NewWithStartWorkflowOperation(options interface{}, workflow interface{}, args ...interface{}) *MockClient_NewWithStartWorkflowOperation_Call { + return &MockClient_NewWithStartWorkflowOperation_Call{Call: _e.mock.On("NewWithStartWorkflowOperation", + append([]interface{}{options, workflow}, args...)...)} +} + +func (_c *MockClient_NewWithStartWorkflowOperation_Call) Run(run func(options client.StartWorkflowOptions, workflow interface{}, args ...interface{})) *MockClient_NewWithStartWorkflowOperation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(client.StartWorkflowOptions), args[1].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_NewWithStartWorkflowOperation_Call) Return(_a0 client.WithStartWorkflowOperation) *MockClient_NewWithStartWorkflowOperation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_NewWithStartWorkflowOperation_Call) RunAndReturn(run func(client.StartWorkflowOptions, interface{}, ...interface{}) client.WithStartWorkflowOperation) *MockClient_NewWithStartWorkflowOperation_Call { + _c.Call.Return(run) + return _c +} + // OperatorService provides a mock function with given fields: func (_m *MockClient) OperatorService() operatorservice.OperatorServiceClient { ret := _m.Called() @@ -1845,6 +1905,65 @@ func (_c *MockClient_TerminateWorkflow_Call) RunAndReturn(run func(context.Conte return _c } +// UpdateWithStartWorkflow provides a mock function with given fields: ctx, options +func (_m *MockClient) UpdateWithStartWorkflow(ctx context.Context, options client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error) { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for UpdateWithStartWorkflow") + } + + var r0 client.WorkflowUpdateHandle + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error)); ok { + return rf(ctx, options) + } + if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWithStartWorkflowOptions) client.WorkflowUpdateHandle); ok { + r0 = rf(ctx, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WorkflowUpdateHandle) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, client.UpdateWithStartWorkflowOptions) error); ok { + r1 = rf(ctx, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_UpdateWithStartWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWithStartWorkflow' +type MockClient_UpdateWithStartWorkflow_Call struct { + *mock.Call +} + +// UpdateWithStartWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - options client.UpdateWithStartWorkflowOptions +func (_e *MockClient_Expecter) UpdateWithStartWorkflow(ctx interface{}, options interface{}) *MockClient_UpdateWithStartWorkflow_Call { + return &MockClient_UpdateWithStartWorkflow_Call{Call: _e.mock.On("UpdateWithStartWorkflow", ctx, options)} +} + +func (_c *MockClient_UpdateWithStartWorkflow_Call) Run(run func(ctx context.Context, options client.UpdateWithStartWorkflowOptions)) *MockClient_UpdateWithStartWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(client.UpdateWithStartWorkflowOptions)) + }) + return _c +} + +func (_c *MockClient_UpdateWithStartWorkflow_Call) Return(_a0 client.WorkflowUpdateHandle, _a1 error) *MockClient_UpdateWithStartWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_UpdateWithStartWorkflow_Call) RunAndReturn(run func(context.Context, client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error)) *MockClient_UpdateWithStartWorkflow_Call { + _c.Call.Return(run) + return _c +} + // UpdateWorkerBuildIdCompatibility provides a mock function with given fields: ctx, options func (_m *MockClient) UpdateWorkerBuildIdCompatibility(ctx context.Context, options *client.UpdateWorkerBuildIdCompatibilityOptions) error { ret := _m.Called(ctx, options) diff --git a/_mocks/opencsg.com/csghub-server/builder/temporal/mock_Client.go b/_mocks/opencsg.com/csghub-server/builder/temporal/mock_Client.go new file mode 100644 index 00000000..cd0fde1a --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/builder/temporal/mock_Client.go @@ -0,0 +1,2319 @@ +// Code generated by mockery v2.49.1. DO NOT EDIT. + +package temporal + +import ( + context "context" + + client "go.temporal.io/sdk/client" + + converter "go.temporal.io/sdk/converter" + + enums "go.temporal.io/api/enums/v1" + + mock "github.com/stretchr/testify/mock" + + operatorservice "go.temporal.io/api/operatorservice/v1" + + worker "go.temporal.io/sdk/worker" + + workflowservice "go.temporal.io/api/workflowservice/v1" +) + +// MockClient is an autogenerated mock type for the Client type +type MockClient struct { + mock.Mock +} + +type MockClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClient) EXPECT() *MockClient_Expecter { + return &MockClient_Expecter{mock: &_m.Mock} +} + +// CancelWorkflow provides a mock function with given fields: ctx, workflowID, runID +func (_m *MockClient) CancelWorkflow(ctx context.Context, workflowID string, runID string) error { + ret := _m.Called(ctx, workflowID, runID) + + if len(ret) == 0 { + panic("no return value specified for CancelWorkflow") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { + r0 = rf(ctx, workflowID, runID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_CancelWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelWorkflow' +type MockClient_CancelWorkflow_Call struct { + *mock.Call +} + +// CancelWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - workflowID string +// - runID string +func (_e *MockClient_Expecter) CancelWorkflow(ctx interface{}, workflowID interface{}, runID interface{}) *MockClient_CancelWorkflow_Call { + return &MockClient_CancelWorkflow_Call{Call: _e.mock.On("CancelWorkflow", ctx, workflowID, runID)} +} + +func (_c *MockClient_CancelWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockClient_CancelWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockClient_CancelWorkflow_Call) Return(_a0 error) *MockClient_CancelWorkflow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_CancelWorkflow_Call) RunAndReturn(run func(context.Context, string, string) error) *MockClient_CancelWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// CheckHealth provides a mock function with given fields: ctx, request +func (_m *MockClient) CheckHealth(ctx context.Context, request *client.CheckHealthRequest) (*client.CheckHealthResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CheckHealth") + } + + var r0 *client.CheckHealthResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *client.CheckHealthRequest) (*client.CheckHealthResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *client.CheckHealthRequest) *client.CheckHealthResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.CheckHealthResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *client.CheckHealthRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth' +type MockClient_CheckHealth_Call struct { + *mock.Call +} + +// CheckHealth is a helper method to define mock.On call +// - ctx context.Context +// - request *client.CheckHealthRequest +func (_e *MockClient_Expecter) CheckHealth(ctx interface{}, request interface{}) *MockClient_CheckHealth_Call { + return &MockClient_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, request)} +} + +func (_c *MockClient_CheckHealth_Call) Run(run func(ctx context.Context, request *client.CheckHealthRequest)) *MockClient_CheckHealth_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*client.CheckHealthRequest)) + }) + return _c +} + +func (_c *MockClient_CheckHealth_Call) Return(_a0 *client.CheckHealthResponse, _a1 error) *MockClient_CheckHealth_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_CheckHealth_Call) RunAndReturn(run func(context.Context, *client.CheckHealthRequest) (*client.CheckHealthResponse, error)) *MockClient_CheckHealth_Call { + _c.Call.Return(run) + return _c +} + +// Close provides a mock function with given fields: +func (_m *MockClient) Close() { + _m.Called() +} + +// MockClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockClient_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *MockClient_Expecter) Close() *MockClient_Close_Call { + return &MockClient_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *MockClient_Close_Call) Run(run func()) *MockClient_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockClient_Close_Call) Return() *MockClient_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClient_Close_Call) RunAndReturn(run func()) *MockClient_Close_Call { + _c.Call.Return(run) + return _c +} + +// CompleteActivity provides a mock function with given fields: ctx, taskToken, result, err +func (_m *MockClient) CompleteActivity(ctx context.Context, taskToken []byte, result interface{}, err error) error { + ret := _m.Called(ctx, taskToken, result, err) + + if len(ret) == 0 { + panic("no return value specified for CompleteActivity") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, []byte, interface{}, error) error); ok { + r0 = rf(ctx, taskToken, result, err) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_CompleteActivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteActivity' +type MockClient_CompleteActivity_Call struct { + *mock.Call +} + +// CompleteActivity is a helper method to define mock.On call +// - ctx context.Context +// - taskToken []byte +// - result interface{} +// - err error +func (_e *MockClient_Expecter) CompleteActivity(ctx interface{}, taskToken interface{}, result interface{}, err interface{}) *MockClient_CompleteActivity_Call { + return &MockClient_CompleteActivity_Call{Call: _e.mock.On("CompleteActivity", ctx, taskToken, result, err)} +} + +func (_c *MockClient_CompleteActivity_Call) Run(run func(ctx context.Context, taskToken []byte, result interface{}, err error)) *MockClient_CompleteActivity_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]byte), args[2].(interface{}), args[3].(error)) + }) + return _c +} + +func (_c *MockClient_CompleteActivity_Call) Return(_a0 error) *MockClient_CompleteActivity_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_CompleteActivity_Call) RunAndReturn(run func(context.Context, []byte, interface{}, error) error) *MockClient_CompleteActivity_Call { + _c.Call.Return(run) + return _c +} + +// CompleteActivityByID provides a mock function with given fields: ctx, namespace, workflowID, runID, activityID, result, err +func (_m *MockClient) CompleteActivityByID(ctx context.Context, namespace string, workflowID string, runID string, activityID string, result interface{}, err error) error { + ret := _m.Called(ctx, namespace, workflowID, runID, activityID, result, err) + + if len(ret) == 0 { + panic("no return value specified for CompleteActivityByID") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, interface{}, error) error); ok { + r0 = rf(ctx, namespace, workflowID, runID, activityID, result, err) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_CompleteActivityByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteActivityByID' +type MockClient_CompleteActivityByID_Call struct { + *mock.Call +} + +// CompleteActivityByID is a helper method to define mock.On call +// - ctx context.Context +// - namespace string +// - workflowID string +// - runID string +// - activityID string +// - result interface{} +// - err error +func (_e *MockClient_Expecter) CompleteActivityByID(ctx interface{}, namespace interface{}, workflowID interface{}, runID interface{}, activityID interface{}, result interface{}, err interface{}) *MockClient_CompleteActivityByID_Call { + return &MockClient_CompleteActivityByID_Call{Call: _e.mock.On("CompleteActivityByID", ctx, namespace, workflowID, runID, activityID, result, err)} +} + +func (_c *MockClient_CompleteActivityByID_Call) Run(run func(ctx context.Context, namespace string, workflowID string, runID string, activityID string, result interface{}, err error)) *MockClient_CompleteActivityByID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(interface{}), args[6].(error)) + }) + return _c +} + +func (_c *MockClient_CompleteActivityByID_Call) Return(_a0 error) *MockClient_CompleteActivityByID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_CompleteActivityByID_Call) RunAndReturn(run func(context.Context, string, string, string, string, interface{}, error) error) *MockClient_CompleteActivityByID_Call { + _c.Call.Return(run) + return _c +} + +// CountWorkflow provides a mock function with given fields: ctx, request +func (_m *MockClient) CountWorkflow(ctx context.Context, request *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CountWorkflow") + } + + var r0 *workflowservice.CountWorkflowExecutionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) *workflowservice.CountWorkflowExecutionsResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.CountWorkflowExecutionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_CountWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountWorkflow' +type MockClient_CountWorkflow_Call struct { + *mock.Call +} + +// CountWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - request *workflowservice.CountWorkflowExecutionsRequest +func (_e *MockClient_Expecter) CountWorkflow(ctx interface{}, request interface{}) *MockClient_CountWorkflow_Call { + return &MockClient_CountWorkflow_Call{Call: _e.mock.On("CountWorkflow", ctx, request)} +} + +func (_c *MockClient_CountWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.CountWorkflowExecutionsRequest)) *MockClient_CountWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflowservice.CountWorkflowExecutionsRequest)) + }) + return _c +} + +func (_c *MockClient_CountWorkflow_Call) Return(_a0 *workflowservice.CountWorkflowExecutionsResponse, _a1 error) *MockClient_CountWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_CountWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error)) *MockClient_CountWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// DescribeTaskQueue provides a mock function with given fields: ctx, taskqueue, taskqueueType +func (_m *MockClient) DescribeTaskQueue(ctx context.Context, taskqueue string, taskqueueType enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error) { + ret := _m.Called(ctx, taskqueue, taskqueueType) + + if len(ret) == 0 { + panic("no return value specified for DescribeTaskQueue") + } + + var r0 *workflowservice.DescribeTaskQueueResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error)); ok { + return rf(ctx, taskqueue, taskqueueType) + } + if rf, ok := ret.Get(0).(func(context.Context, string, enums.TaskQueueType) *workflowservice.DescribeTaskQueueResponse); ok { + r0 = rf(ctx, taskqueue, taskqueueType) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.DescribeTaskQueueResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, enums.TaskQueueType) error); ok { + r1 = rf(ctx, taskqueue, taskqueueType) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_DescribeTaskQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTaskQueue' +type MockClient_DescribeTaskQueue_Call struct { + *mock.Call +} + +// DescribeTaskQueue is a helper method to define mock.On call +// - ctx context.Context +// - taskqueue string +// - taskqueueType enums.TaskQueueType +func (_e *MockClient_Expecter) DescribeTaskQueue(ctx interface{}, taskqueue interface{}, taskqueueType interface{}) *MockClient_DescribeTaskQueue_Call { + return &MockClient_DescribeTaskQueue_Call{Call: _e.mock.On("DescribeTaskQueue", ctx, taskqueue, taskqueueType)} +} + +func (_c *MockClient_DescribeTaskQueue_Call) Run(run func(ctx context.Context, taskqueue string, taskqueueType enums.TaskQueueType)) *MockClient_DescribeTaskQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(enums.TaskQueueType)) + }) + return _c +} + +func (_c *MockClient_DescribeTaskQueue_Call) Return(_a0 *workflowservice.DescribeTaskQueueResponse, _a1 error) *MockClient_DescribeTaskQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_DescribeTaskQueue_Call) RunAndReturn(run func(context.Context, string, enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error)) *MockClient_DescribeTaskQueue_Call { + _c.Call.Return(run) + return _c +} + +// DescribeTaskQueueEnhanced provides a mock function with given fields: ctx, options +func (_m *MockClient) DescribeTaskQueueEnhanced(ctx context.Context, options client.DescribeTaskQueueEnhancedOptions) (client.TaskQueueDescription, error) { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for DescribeTaskQueueEnhanced") + } + + var r0 client.TaskQueueDescription + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.DescribeTaskQueueEnhancedOptions) (client.TaskQueueDescription, error)); ok { + return rf(ctx, options) + } + if rf, ok := ret.Get(0).(func(context.Context, client.DescribeTaskQueueEnhancedOptions) client.TaskQueueDescription); ok { + r0 = rf(ctx, options) + } else { + r0 = ret.Get(0).(client.TaskQueueDescription) + } + + if rf, ok := ret.Get(1).(func(context.Context, client.DescribeTaskQueueEnhancedOptions) error); ok { + r1 = rf(ctx, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_DescribeTaskQueueEnhanced_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTaskQueueEnhanced' +type MockClient_DescribeTaskQueueEnhanced_Call struct { + *mock.Call +} + +// DescribeTaskQueueEnhanced is a helper method to define mock.On call +// - ctx context.Context +// - options client.DescribeTaskQueueEnhancedOptions +func (_e *MockClient_Expecter) DescribeTaskQueueEnhanced(ctx interface{}, options interface{}) *MockClient_DescribeTaskQueueEnhanced_Call { + return &MockClient_DescribeTaskQueueEnhanced_Call{Call: _e.mock.On("DescribeTaskQueueEnhanced", ctx, options)} +} + +func (_c *MockClient_DescribeTaskQueueEnhanced_Call) Run(run func(ctx context.Context, options client.DescribeTaskQueueEnhancedOptions)) *MockClient_DescribeTaskQueueEnhanced_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(client.DescribeTaskQueueEnhancedOptions)) + }) + return _c +} + +func (_c *MockClient_DescribeTaskQueueEnhanced_Call) Return(_a0 client.TaskQueueDescription, _a1 error) *MockClient_DescribeTaskQueueEnhanced_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_DescribeTaskQueueEnhanced_Call) RunAndReturn(run func(context.Context, client.DescribeTaskQueueEnhancedOptions) (client.TaskQueueDescription, error)) *MockClient_DescribeTaskQueueEnhanced_Call { + _c.Call.Return(run) + return _c +} + +// DescribeWorkflowExecution provides a mock function with given fields: ctx, workflowID, runID +func (_m *MockClient) DescribeWorkflowExecution(ctx context.Context, workflowID string, runID string) (*workflowservice.DescribeWorkflowExecutionResponse, error) { + ret := _m.Called(ctx, workflowID, runID) + + if len(ret) == 0 { + panic("no return value specified for DescribeWorkflowExecution") + } + + var r0 *workflowservice.DescribeWorkflowExecutionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) (*workflowservice.DescribeWorkflowExecutionResponse, error)); ok { + return rf(ctx, workflowID, runID) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string) *workflowservice.DescribeWorkflowExecutionResponse); ok { + r0 = rf(ctx, workflowID, runID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.DescribeWorkflowExecutionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = rf(ctx, workflowID, runID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_DescribeWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeWorkflowExecution' +type MockClient_DescribeWorkflowExecution_Call struct { + *mock.Call +} + +// DescribeWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - workflowID string +// - runID string +func (_e *MockClient_Expecter) DescribeWorkflowExecution(ctx interface{}, workflowID interface{}, runID interface{}) *MockClient_DescribeWorkflowExecution_Call { + return &MockClient_DescribeWorkflowExecution_Call{Call: _e.mock.On("DescribeWorkflowExecution", ctx, workflowID, runID)} +} + +func (_c *MockClient_DescribeWorkflowExecution_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockClient_DescribeWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockClient_DescribeWorkflowExecution_Call) Return(_a0 *workflowservice.DescribeWorkflowExecutionResponse, _a1 error) *MockClient_DescribeWorkflowExecution_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_DescribeWorkflowExecution_Call) RunAndReturn(run func(context.Context, string, string) (*workflowservice.DescribeWorkflowExecutionResponse, error)) *MockClient_DescribeWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// ExecuteWorkflow provides a mock function with given fields: ctx, options, workflow, args +func (_m *MockClient) ExecuteWorkflow(ctx context.Context, options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) (client.WorkflowRun, error) { + var _ca []interface{} + _ca = append(_ca, ctx, options, workflow) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ExecuteWorkflow") + } + + var r0 client.WorkflowRun + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)); ok { + return rf(ctx, options, workflow, args...) + } + if rf, ok := ret.Get(0).(func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) client.WorkflowRun); ok { + r0 = rf(ctx, options, workflow, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WorkflowRun) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) error); ok { + r1 = rf(ctx, options, workflow, args...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_ExecuteWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteWorkflow' +type MockClient_ExecuteWorkflow_Call struct { + *mock.Call +} + +// ExecuteWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - options client.StartWorkflowOptions +// - workflow interface{} +// - args ...interface{} +func (_e *MockClient_Expecter) ExecuteWorkflow(ctx interface{}, options interface{}, workflow interface{}, args ...interface{}) *MockClient_ExecuteWorkflow_Call { + return &MockClient_ExecuteWorkflow_Call{Call: _e.mock.On("ExecuteWorkflow", + append([]interface{}{ctx, options, workflow}, args...)...)} +} + +func (_c *MockClient_ExecuteWorkflow_Call) Run(run func(ctx context.Context, options client.StartWorkflowOptions, workflow interface{}, args ...interface{})) *MockClient_ExecuteWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(client.StartWorkflowOptions), args[2].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_ExecuteWorkflow_Call) Return(_a0 client.WorkflowRun, _a1 error) *MockClient_ExecuteWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_ExecuteWorkflow_Call) RunAndReturn(run func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)) *MockClient_ExecuteWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// GetSearchAttributes provides a mock function with given fields: ctx +func (_m *MockClient) GetSearchAttributes(ctx context.Context) (*workflowservice.GetSearchAttributesResponse, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetSearchAttributes") + } + + var r0 *workflowservice.GetSearchAttributesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*workflowservice.GetSearchAttributesResponse, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) *workflowservice.GetSearchAttributesResponse); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.GetSearchAttributesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_GetSearchAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSearchAttributes' +type MockClient_GetSearchAttributes_Call struct { + *mock.Call +} + +// GetSearchAttributes is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockClient_Expecter) GetSearchAttributes(ctx interface{}) *MockClient_GetSearchAttributes_Call { + return &MockClient_GetSearchAttributes_Call{Call: _e.mock.On("GetSearchAttributes", ctx)} +} + +func (_c *MockClient_GetSearchAttributes_Call) Run(run func(ctx context.Context)) *MockClient_GetSearchAttributes_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockClient_GetSearchAttributes_Call) Return(_a0 *workflowservice.GetSearchAttributesResponse, _a1 error) *MockClient_GetSearchAttributes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_GetSearchAttributes_Call) RunAndReturn(run func(context.Context) (*workflowservice.GetSearchAttributesResponse, error)) *MockClient_GetSearchAttributes_Call { + _c.Call.Return(run) + return _c +} + +// GetWorkerBuildIdCompatibility provides a mock function with given fields: ctx, options +func (_m *MockClient) GetWorkerBuildIdCompatibility(ctx context.Context, options *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error) { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for GetWorkerBuildIdCompatibility") + } + + var r0 *client.WorkerBuildIDVersionSets + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error)); ok { + return rf(ctx, options) + } + if rf, ok := ret.Get(0).(func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) *client.WorkerBuildIDVersionSets); ok { + r0 = rf(ctx, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.WorkerBuildIDVersionSets) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) error); ok { + r1 = rf(ctx, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_GetWorkerBuildIdCompatibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerBuildIdCompatibility' +type MockClient_GetWorkerBuildIdCompatibility_Call struct { + *mock.Call +} + +// GetWorkerBuildIdCompatibility is a helper method to define mock.On call +// - ctx context.Context +// - options *client.GetWorkerBuildIdCompatibilityOptions +func (_e *MockClient_Expecter) GetWorkerBuildIdCompatibility(ctx interface{}, options interface{}) *MockClient_GetWorkerBuildIdCompatibility_Call { + return &MockClient_GetWorkerBuildIdCompatibility_Call{Call: _e.mock.On("GetWorkerBuildIdCompatibility", ctx, options)} +} + +func (_c *MockClient_GetWorkerBuildIdCompatibility_Call) Run(run func(ctx context.Context, options *client.GetWorkerBuildIdCompatibilityOptions)) *MockClient_GetWorkerBuildIdCompatibility_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*client.GetWorkerBuildIdCompatibilityOptions)) + }) + return _c +} + +func (_c *MockClient_GetWorkerBuildIdCompatibility_Call) Return(_a0 *client.WorkerBuildIDVersionSets, _a1 error) *MockClient_GetWorkerBuildIdCompatibility_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_GetWorkerBuildIdCompatibility_Call) RunAndReturn(run func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error)) *MockClient_GetWorkerBuildIdCompatibility_Call { + _c.Call.Return(run) + return _c +} + +// GetWorkerTaskReachability provides a mock function with given fields: ctx, options +func (_m *MockClient) GetWorkerTaskReachability(ctx context.Context, options *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error) { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for GetWorkerTaskReachability") + } + + var r0 *client.WorkerTaskReachability + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error)); ok { + return rf(ctx, options) + } + if rf, ok := ret.Get(0).(func(context.Context, *client.GetWorkerTaskReachabilityOptions) *client.WorkerTaskReachability); ok { + r0 = rf(ctx, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.WorkerTaskReachability) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *client.GetWorkerTaskReachabilityOptions) error); ok { + r1 = rf(ctx, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_GetWorkerTaskReachability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerTaskReachability' +type MockClient_GetWorkerTaskReachability_Call struct { + *mock.Call +} + +// GetWorkerTaskReachability is a helper method to define mock.On call +// - ctx context.Context +// - options *client.GetWorkerTaskReachabilityOptions +func (_e *MockClient_Expecter) GetWorkerTaskReachability(ctx interface{}, options interface{}) *MockClient_GetWorkerTaskReachability_Call { + return &MockClient_GetWorkerTaskReachability_Call{Call: _e.mock.On("GetWorkerTaskReachability", ctx, options)} +} + +func (_c *MockClient_GetWorkerTaskReachability_Call) Run(run func(ctx context.Context, options *client.GetWorkerTaskReachabilityOptions)) *MockClient_GetWorkerTaskReachability_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*client.GetWorkerTaskReachabilityOptions)) + }) + return _c +} + +func (_c *MockClient_GetWorkerTaskReachability_Call) Return(_a0 *client.WorkerTaskReachability, _a1 error) *MockClient_GetWorkerTaskReachability_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_GetWorkerTaskReachability_Call) RunAndReturn(run func(context.Context, *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error)) *MockClient_GetWorkerTaskReachability_Call { + _c.Call.Return(run) + return _c +} + +// GetWorkerVersioningRules provides a mock function with given fields: ctx, options +func (_m *MockClient) GetWorkerVersioningRules(ctx context.Context, options client.GetWorkerVersioningOptions) (*client.WorkerVersioningRules, error) { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for GetWorkerVersioningRules") + } + + var r0 *client.WorkerVersioningRules + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.GetWorkerVersioningOptions) (*client.WorkerVersioningRules, error)); ok { + return rf(ctx, options) + } + if rf, ok := ret.Get(0).(func(context.Context, client.GetWorkerVersioningOptions) *client.WorkerVersioningRules); ok { + r0 = rf(ctx, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.WorkerVersioningRules) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, client.GetWorkerVersioningOptions) error); ok { + r1 = rf(ctx, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_GetWorkerVersioningRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerVersioningRules' +type MockClient_GetWorkerVersioningRules_Call struct { + *mock.Call +} + +// GetWorkerVersioningRules is a helper method to define mock.On call +// - ctx context.Context +// - options client.GetWorkerVersioningOptions +func (_e *MockClient_Expecter) GetWorkerVersioningRules(ctx interface{}, options interface{}) *MockClient_GetWorkerVersioningRules_Call { + return &MockClient_GetWorkerVersioningRules_Call{Call: _e.mock.On("GetWorkerVersioningRules", ctx, options)} +} + +func (_c *MockClient_GetWorkerVersioningRules_Call) Run(run func(ctx context.Context, options client.GetWorkerVersioningOptions)) *MockClient_GetWorkerVersioningRules_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(client.GetWorkerVersioningOptions)) + }) + return _c +} + +func (_c *MockClient_GetWorkerVersioningRules_Call) Return(_a0 *client.WorkerVersioningRules, _a1 error) *MockClient_GetWorkerVersioningRules_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_GetWorkerVersioningRules_Call) RunAndReturn(run func(context.Context, client.GetWorkerVersioningOptions) (*client.WorkerVersioningRules, error)) *MockClient_GetWorkerVersioningRules_Call { + _c.Call.Return(run) + return _c +} + +// GetWorkflow provides a mock function with given fields: ctx, workflowID, runID +func (_m *MockClient) GetWorkflow(ctx context.Context, workflowID string, runID string) client.WorkflowRun { + ret := _m.Called(ctx, workflowID, runID) + + if len(ret) == 0 { + panic("no return value specified for GetWorkflow") + } + + var r0 client.WorkflowRun + if rf, ok := ret.Get(0).(func(context.Context, string, string) client.WorkflowRun); ok { + r0 = rf(ctx, workflowID, runID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WorkflowRun) + } + } + + return r0 +} + +// MockClient_GetWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflow' +type MockClient_GetWorkflow_Call struct { + *mock.Call +} + +// GetWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - workflowID string +// - runID string +func (_e *MockClient_Expecter) GetWorkflow(ctx interface{}, workflowID interface{}, runID interface{}) *MockClient_GetWorkflow_Call { + return &MockClient_GetWorkflow_Call{Call: _e.mock.On("GetWorkflow", ctx, workflowID, runID)} +} + +func (_c *MockClient_GetWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockClient_GetWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockClient_GetWorkflow_Call) Return(_a0 client.WorkflowRun) *MockClient_GetWorkflow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_GetWorkflow_Call) RunAndReturn(run func(context.Context, string, string) client.WorkflowRun) *MockClient_GetWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// GetWorkflowHistory provides a mock function with given fields: ctx, workflowID, runID, isLongPoll, filterType +func (_m *MockClient) GetWorkflowHistory(ctx context.Context, workflowID string, runID string, isLongPoll bool, filterType enums.HistoryEventFilterType) client.HistoryEventIterator { + ret := _m.Called(ctx, workflowID, runID, isLongPoll, filterType) + + if len(ret) == 0 { + panic("no return value specified for GetWorkflowHistory") + } + + var r0 client.HistoryEventIterator + if rf, ok := ret.Get(0).(func(context.Context, string, string, bool, enums.HistoryEventFilterType) client.HistoryEventIterator); ok { + r0 = rf(ctx, workflowID, runID, isLongPoll, filterType) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.HistoryEventIterator) + } + } + + return r0 +} + +// MockClient_GetWorkflowHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflowHistory' +type MockClient_GetWorkflowHistory_Call struct { + *mock.Call +} + +// GetWorkflowHistory is a helper method to define mock.On call +// - ctx context.Context +// - workflowID string +// - runID string +// - isLongPoll bool +// - filterType enums.HistoryEventFilterType +func (_e *MockClient_Expecter) GetWorkflowHistory(ctx interface{}, workflowID interface{}, runID interface{}, isLongPoll interface{}, filterType interface{}) *MockClient_GetWorkflowHistory_Call { + return &MockClient_GetWorkflowHistory_Call{Call: _e.mock.On("GetWorkflowHistory", ctx, workflowID, runID, isLongPoll, filterType)} +} + +func (_c *MockClient_GetWorkflowHistory_Call) Run(run func(ctx context.Context, workflowID string, runID string, isLongPoll bool, filterType enums.HistoryEventFilterType)) *MockClient_GetWorkflowHistory_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool), args[4].(enums.HistoryEventFilterType)) + }) + return _c +} + +func (_c *MockClient_GetWorkflowHistory_Call) Return(_a0 client.HistoryEventIterator) *MockClient_GetWorkflowHistory_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_GetWorkflowHistory_Call) RunAndReturn(run func(context.Context, string, string, bool, enums.HistoryEventFilterType) client.HistoryEventIterator) *MockClient_GetWorkflowHistory_Call { + _c.Call.Return(run) + return _c +} + +// GetWorkflowUpdateHandle provides a mock function with given fields: ref +func (_m *MockClient) GetWorkflowUpdateHandle(ref client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle { + ret := _m.Called(ref) + + if len(ret) == 0 { + panic("no return value specified for GetWorkflowUpdateHandle") + } + + var r0 client.WorkflowUpdateHandle + if rf, ok := ret.Get(0).(func(client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle); ok { + r0 = rf(ref) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WorkflowUpdateHandle) + } + } + + return r0 +} + +// MockClient_GetWorkflowUpdateHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflowUpdateHandle' +type MockClient_GetWorkflowUpdateHandle_Call struct { + *mock.Call +} + +// GetWorkflowUpdateHandle is a helper method to define mock.On call +// - ref client.GetWorkflowUpdateHandleOptions +func (_e *MockClient_Expecter) GetWorkflowUpdateHandle(ref interface{}) *MockClient_GetWorkflowUpdateHandle_Call { + return &MockClient_GetWorkflowUpdateHandle_Call{Call: _e.mock.On("GetWorkflowUpdateHandle", ref)} +} + +func (_c *MockClient_GetWorkflowUpdateHandle_Call) Run(run func(ref client.GetWorkflowUpdateHandleOptions)) *MockClient_GetWorkflowUpdateHandle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(client.GetWorkflowUpdateHandleOptions)) + }) + return _c +} + +func (_c *MockClient_GetWorkflowUpdateHandle_Call) Return(_a0 client.WorkflowUpdateHandle) *MockClient_GetWorkflowUpdateHandle_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_GetWorkflowUpdateHandle_Call) RunAndReturn(run func(client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle) *MockClient_GetWorkflowUpdateHandle_Call { + _c.Call.Return(run) + return _c +} + +// ListArchivedWorkflow provides a mock function with given fields: ctx, request +func (_m *MockClient) ListArchivedWorkflow(ctx context.Context, request *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ListArchivedWorkflow") + } + + var r0 *workflowservice.ListArchivedWorkflowExecutionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) *workflowservice.ListArchivedWorkflowExecutionsResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.ListArchivedWorkflowExecutionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_ListArchivedWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListArchivedWorkflow' +type MockClient_ListArchivedWorkflow_Call struct { + *mock.Call +} + +// ListArchivedWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - request *workflowservice.ListArchivedWorkflowExecutionsRequest +func (_e *MockClient_Expecter) ListArchivedWorkflow(ctx interface{}, request interface{}) *MockClient_ListArchivedWorkflow_Call { + return &MockClient_ListArchivedWorkflow_Call{Call: _e.mock.On("ListArchivedWorkflow", ctx, request)} +} + +func (_c *MockClient_ListArchivedWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListArchivedWorkflowExecutionsRequest)) *MockClient_ListArchivedWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflowservice.ListArchivedWorkflowExecutionsRequest)) + }) + return _c +} + +func (_c *MockClient_ListArchivedWorkflow_Call) Return(_a0 *workflowservice.ListArchivedWorkflowExecutionsResponse, _a1 error) *MockClient_ListArchivedWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_ListArchivedWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error)) *MockClient_ListArchivedWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// ListClosedWorkflow provides a mock function with given fields: ctx, request +func (_m *MockClient) ListClosedWorkflow(ctx context.Context, request *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ListClosedWorkflow") + } + + var r0 *workflowservice.ListClosedWorkflowExecutionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) *workflowservice.ListClosedWorkflowExecutionsResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.ListClosedWorkflowExecutionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_ListClosedWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClosedWorkflow' +type MockClient_ListClosedWorkflow_Call struct { + *mock.Call +} + +// ListClosedWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - request *workflowservice.ListClosedWorkflowExecutionsRequest +func (_e *MockClient_Expecter) ListClosedWorkflow(ctx interface{}, request interface{}) *MockClient_ListClosedWorkflow_Call { + return &MockClient_ListClosedWorkflow_Call{Call: _e.mock.On("ListClosedWorkflow", ctx, request)} +} + +func (_c *MockClient_ListClosedWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListClosedWorkflowExecutionsRequest)) *MockClient_ListClosedWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflowservice.ListClosedWorkflowExecutionsRequest)) + }) + return _c +} + +func (_c *MockClient_ListClosedWorkflow_Call) Return(_a0 *workflowservice.ListClosedWorkflowExecutionsResponse, _a1 error) *MockClient_ListClosedWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_ListClosedWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error)) *MockClient_ListClosedWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// ListOpenWorkflow provides a mock function with given fields: ctx, request +func (_m *MockClient) ListOpenWorkflow(ctx context.Context, request *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ListOpenWorkflow") + } + + var r0 *workflowservice.ListOpenWorkflowExecutionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) *workflowservice.ListOpenWorkflowExecutionsResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.ListOpenWorkflowExecutionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_ListOpenWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOpenWorkflow' +type MockClient_ListOpenWorkflow_Call struct { + *mock.Call +} + +// ListOpenWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - request *workflowservice.ListOpenWorkflowExecutionsRequest +func (_e *MockClient_Expecter) ListOpenWorkflow(ctx interface{}, request interface{}) *MockClient_ListOpenWorkflow_Call { + return &MockClient_ListOpenWorkflow_Call{Call: _e.mock.On("ListOpenWorkflow", ctx, request)} +} + +func (_c *MockClient_ListOpenWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListOpenWorkflowExecutionsRequest)) *MockClient_ListOpenWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflowservice.ListOpenWorkflowExecutionsRequest)) + }) + return _c +} + +func (_c *MockClient_ListOpenWorkflow_Call) Return(_a0 *workflowservice.ListOpenWorkflowExecutionsResponse, _a1 error) *MockClient_ListOpenWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_ListOpenWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error)) *MockClient_ListOpenWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// ListWorkflow provides a mock function with given fields: ctx, request +func (_m *MockClient) ListWorkflow(ctx context.Context, request *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ListWorkflow") + } + + var r0 *workflowservice.ListWorkflowExecutionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) *workflowservice.ListWorkflowExecutionsResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.ListWorkflowExecutionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_ListWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWorkflow' +type MockClient_ListWorkflow_Call struct { + *mock.Call +} + +// ListWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - request *workflowservice.ListWorkflowExecutionsRequest +func (_e *MockClient_Expecter) ListWorkflow(ctx interface{}, request interface{}) *MockClient_ListWorkflow_Call { + return &MockClient_ListWorkflow_Call{Call: _e.mock.On("ListWorkflow", ctx, request)} +} + +func (_c *MockClient_ListWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListWorkflowExecutionsRequest)) *MockClient_ListWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflowservice.ListWorkflowExecutionsRequest)) + }) + return _c +} + +func (_c *MockClient_ListWorkflow_Call) Return(_a0 *workflowservice.ListWorkflowExecutionsResponse, _a1 error) *MockClient_ListWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_ListWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error)) *MockClient_ListWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// NewWithStartWorkflowOperation provides a mock function with given fields: options, workflow, args +func (_m *MockClient) NewWithStartWorkflowOperation(options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) client.WithStartWorkflowOperation { + var _ca []interface{} + _ca = append(_ca, options, workflow) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for NewWithStartWorkflowOperation") + } + + var r0 client.WithStartWorkflowOperation + if rf, ok := ret.Get(0).(func(client.StartWorkflowOptions, interface{}, ...interface{}) client.WithStartWorkflowOperation); ok { + r0 = rf(options, workflow, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WithStartWorkflowOperation) + } + } + + return r0 +} + +// MockClient_NewWithStartWorkflowOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewWithStartWorkflowOperation' +type MockClient_NewWithStartWorkflowOperation_Call struct { + *mock.Call +} + +// NewWithStartWorkflowOperation is a helper method to define mock.On call +// - options client.StartWorkflowOptions +// - workflow interface{} +// - args ...interface{} +func (_e *MockClient_Expecter) NewWithStartWorkflowOperation(options interface{}, workflow interface{}, args ...interface{}) *MockClient_NewWithStartWorkflowOperation_Call { + return &MockClient_NewWithStartWorkflowOperation_Call{Call: _e.mock.On("NewWithStartWorkflowOperation", + append([]interface{}{options, workflow}, args...)...)} +} + +func (_c *MockClient_NewWithStartWorkflowOperation_Call) Run(run func(options client.StartWorkflowOptions, workflow interface{}, args ...interface{})) *MockClient_NewWithStartWorkflowOperation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(client.StartWorkflowOptions), args[1].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_NewWithStartWorkflowOperation_Call) Return(_a0 client.WithStartWorkflowOperation) *MockClient_NewWithStartWorkflowOperation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_NewWithStartWorkflowOperation_Call) RunAndReturn(run func(client.StartWorkflowOptions, interface{}, ...interface{}) client.WithStartWorkflowOperation) *MockClient_NewWithStartWorkflowOperation_Call { + _c.Call.Return(run) + return _c +} + +// NewWorker provides a mock function with given fields: queue, options +func (_m *MockClient) NewWorker(queue string, options worker.Options) worker.Registry { + ret := _m.Called(queue, options) + + if len(ret) == 0 { + panic("no return value specified for NewWorker") + } + + var r0 worker.Registry + if rf, ok := ret.Get(0).(func(string, worker.Options) worker.Registry); ok { + r0 = rf(queue, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(worker.Registry) + } + } + + return r0 +} + +// MockClient_NewWorker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewWorker' +type MockClient_NewWorker_Call struct { + *mock.Call +} + +// NewWorker is a helper method to define mock.On call +// - queue string +// - options worker.Options +func (_e *MockClient_Expecter) NewWorker(queue interface{}, options interface{}) *MockClient_NewWorker_Call { + return &MockClient_NewWorker_Call{Call: _e.mock.On("NewWorker", queue, options)} +} + +func (_c *MockClient_NewWorker_Call) Run(run func(queue string, options worker.Options)) *MockClient_NewWorker_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(worker.Options)) + }) + return _c +} + +func (_c *MockClient_NewWorker_Call) Return(_a0 worker.Registry) *MockClient_NewWorker_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_NewWorker_Call) RunAndReturn(run func(string, worker.Options) worker.Registry) *MockClient_NewWorker_Call { + _c.Call.Return(run) + return _c +} + +// OperatorService provides a mock function with given fields: +func (_m *MockClient) OperatorService() operatorservice.OperatorServiceClient { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for OperatorService") + } + + var r0 operatorservice.OperatorServiceClient + if rf, ok := ret.Get(0).(func() operatorservice.OperatorServiceClient); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(operatorservice.OperatorServiceClient) + } + } + + return r0 +} + +// MockClient_OperatorService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperatorService' +type MockClient_OperatorService_Call struct { + *mock.Call +} + +// OperatorService is a helper method to define mock.On call +func (_e *MockClient_Expecter) OperatorService() *MockClient_OperatorService_Call { + return &MockClient_OperatorService_Call{Call: _e.mock.On("OperatorService")} +} + +func (_c *MockClient_OperatorService_Call) Run(run func()) *MockClient_OperatorService_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockClient_OperatorService_Call) Return(_a0 operatorservice.OperatorServiceClient) *MockClient_OperatorService_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_OperatorService_Call) RunAndReturn(run func() operatorservice.OperatorServiceClient) *MockClient_OperatorService_Call { + _c.Call.Return(run) + return _c +} + +// QueryWorkflow provides a mock function with given fields: ctx, workflowID, runID, queryType, args +func (_m *MockClient) QueryWorkflow(ctx context.Context, workflowID string, runID string, queryType string, args ...interface{}) (converter.EncodedValue, error) { + var _ca []interface{} + _ca = append(_ca, ctx, workflowID, runID, queryType) + _ca = append(_ca, args...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for QueryWorkflow") + } + + var r0 converter.EncodedValue + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, ...interface{}) (converter.EncodedValue, error)); ok { + return rf(ctx, workflowID, runID, queryType, args...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, ...interface{}) converter.EncodedValue); ok { + r0 = rf(ctx, workflowID, runID, queryType, args...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(converter.EncodedValue) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string, string, ...interface{}) error); ok { + r1 = rf(ctx, workflowID, runID, queryType, args...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_QueryWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryWorkflow' +type MockClient_QueryWorkflow_Call struct { + *mock.Call +} + +// QueryWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - workflowID string +// - runID string +// - queryType string +// - args ...interface{} +func (_e *MockClient_Expecter) QueryWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, queryType interface{}, args ...interface{}) *MockClient_QueryWorkflow_Call { + return &MockClient_QueryWorkflow_Call{Call: _e.mock.On("QueryWorkflow", + append([]interface{}{ctx, workflowID, runID, queryType}, args...)...)} +} + +func (_c *MockClient_QueryWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, queryType string, args ...interface{})) *MockClient_QueryWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_QueryWorkflow_Call) Return(_a0 converter.EncodedValue, _a1 error) *MockClient_QueryWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_QueryWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, ...interface{}) (converter.EncodedValue, error)) *MockClient_QueryWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// QueryWorkflowWithOptions provides a mock function with given fields: ctx, request +func (_m *MockClient) QueryWorkflowWithOptions(ctx context.Context, request *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for QueryWorkflowWithOptions") + } + + var r0 *client.QueryWorkflowWithOptionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *client.QueryWorkflowWithOptionsRequest) *client.QueryWorkflowWithOptionsResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.QueryWorkflowWithOptionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *client.QueryWorkflowWithOptionsRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_QueryWorkflowWithOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryWorkflowWithOptions' +type MockClient_QueryWorkflowWithOptions_Call struct { + *mock.Call +} + +// QueryWorkflowWithOptions is a helper method to define mock.On call +// - ctx context.Context +// - request *client.QueryWorkflowWithOptionsRequest +func (_e *MockClient_Expecter) QueryWorkflowWithOptions(ctx interface{}, request interface{}) *MockClient_QueryWorkflowWithOptions_Call { + return &MockClient_QueryWorkflowWithOptions_Call{Call: _e.mock.On("QueryWorkflowWithOptions", ctx, request)} +} + +func (_c *MockClient_QueryWorkflowWithOptions_Call) Run(run func(ctx context.Context, request *client.QueryWorkflowWithOptionsRequest)) *MockClient_QueryWorkflowWithOptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*client.QueryWorkflowWithOptionsRequest)) + }) + return _c +} + +func (_c *MockClient_QueryWorkflowWithOptions_Call) Return(_a0 *client.QueryWorkflowWithOptionsResponse, _a1 error) *MockClient_QueryWorkflowWithOptions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_QueryWorkflowWithOptions_Call) RunAndReturn(run func(context.Context, *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error)) *MockClient_QueryWorkflowWithOptions_Call { + _c.Call.Return(run) + return _c +} + +// RecordActivityHeartbeat provides a mock function with given fields: ctx, taskToken, details +func (_m *MockClient) RecordActivityHeartbeat(ctx context.Context, taskToken []byte, details ...interface{}) error { + var _ca []interface{} + _ca = append(_ca, ctx, taskToken) + _ca = append(_ca, details...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RecordActivityHeartbeat") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, []byte, ...interface{}) error); ok { + r0 = rf(ctx, taskToken, details...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_RecordActivityHeartbeat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordActivityHeartbeat' +type MockClient_RecordActivityHeartbeat_Call struct { + *mock.Call +} + +// RecordActivityHeartbeat is a helper method to define mock.On call +// - ctx context.Context +// - taskToken []byte +// - details ...interface{} +func (_e *MockClient_Expecter) RecordActivityHeartbeat(ctx interface{}, taskToken interface{}, details ...interface{}) *MockClient_RecordActivityHeartbeat_Call { + return &MockClient_RecordActivityHeartbeat_Call{Call: _e.mock.On("RecordActivityHeartbeat", + append([]interface{}{ctx, taskToken}, details...)...)} +} + +func (_c *MockClient_RecordActivityHeartbeat_Call) Run(run func(ctx context.Context, taskToken []byte, details ...interface{})) *MockClient_RecordActivityHeartbeat_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].([]byte), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_RecordActivityHeartbeat_Call) Return(_a0 error) *MockClient_RecordActivityHeartbeat_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_RecordActivityHeartbeat_Call) RunAndReturn(run func(context.Context, []byte, ...interface{}) error) *MockClient_RecordActivityHeartbeat_Call { + _c.Call.Return(run) + return _c +} + +// RecordActivityHeartbeatByID provides a mock function with given fields: ctx, namespace, workflowID, runID, activityID, details +func (_m *MockClient) RecordActivityHeartbeatByID(ctx context.Context, namespace string, workflowID string, runID string, activityID string, details ...interface{}) error { + var _ca []interface{} + _ca = append(_ca, ctx, namespace, workflowID, runID, activityID) + _ca = append(_ca, details...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RecordActivityHeartbeatByID") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, ...interface{}) error); ok { + r0 = rf(ctx, namespace, workflowID, runID, activityID, details...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_RecordActivityHeartbeatByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordActivityHeartbeatByID' +type MockClient_RecordActivityHeartbeatByID_Call struct { + *mock.Call +} + +// RecordActivityHeartbeatByID is a helper method to define mock.On call +// - ctx context.Context +// - namespace string +// - workflowID string +// - runID string +// - activityID string +// - details ...interface{} +func (_e *MockClient_Expecter) RecordActivityHeartbeatByID(ctx interface{}, namespace interface{}, workflowID interface{}, runID interface{}, activityID interface{}, details ...interface{}) *MockClient_RecordActivityHeartbeatByID_Call { + return &MockClient_RecordActivityHeartbeatByID_Call{Call: _e.mock.On("RecordActivityHeartbeatByID", + append([]interface{}{ctx, namespace, workflowID, runID, activityID}, details...)...)} +} + +func (_c *MockClient_RecordActivityHeartbeatByID_Call) Run(run func(ctx context.Context, namespace string, workflowID string, runID string, activityID string, details ...interface{})) *MockClient_RecordActivityHeartbeatByID_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-5) + for i, a := range args[5:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_RecordActivityHeartbeatByID_Call) Return(_a0 error) *MockClient_RecordActivityHeartbeatByID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_RecordActivityHeartbeatByID_Call) RunAndReturn(run func(context.Context, string, string, string, string, ...interface{}) error) *MockClient_RecordActivityHeartbeatByID_Call { + _c.Call.Return(run) + return _c +} + +// ResetWorkflowExecution provides a mock function with given fields: ctx, request +func (_m *MockClient) ResetWorkflowExecution(ctx context.Context, request *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ResetWorkflowExecution") + } + + var r0 *workflowservice.ResetWorkflowExecutionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) *workflowservice.ResetWorkflowExecutionResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.ResetWorkflowExecutionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_ResetWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetWorkflowExecution' +type MockClient_ResetWorkflowExecution_Call struct { + *mock.Call +} + +// ResetWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *workflowservice.ResetWorkflowExecutionRequest +func (_e *MockClient_Expecter) ResetWorkflowExecution(ctx interface{}, request interface{}) *MockClient_ResetWorkflowExecution_Call { + return &MockClient_ResetWorkflowExecution_Call{Call: _e.mock.On("ResetWorkflowExecution", ctx, request)} +} + +func (_c *MockClient_ResetWorkflowExecution_Call) Run(run func(ctx context.Context, request *workflowservice.ResetWorkflowExecutionRequest)) *MockClient_ResetWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflowservice.ResetWorkflowExecutionRequest)) + }) + return _c +} + +func (_c *MockClient_ResetWorkflowExecution_Call) Return(_a0 *workflowservice.ResetWorkflowExecutionResponse, _a1 error) *MockClient_ResetWorkflowExecution_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_ResetWorkflowExecution_Call) RunAndReturn(run func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error)) *MockClient_ResetWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// ScanWorkflow provides a mock function with given fields: ctx, request +func (_m *MockClient) ScanWorkflow(ctx context.Context, request *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error) { + ret := _m.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ScanWorkflow") + } + + var r0 *workflowservice.ScanWorkflowExecutionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error)); ok { + return rf(ctx, request) + } + if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) *workflowservice.ScanWorkflowExecutionsResponse); ok { + r0 = rf(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*workflowservice.ScanWorkflowExecutionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) error); ok { + r1 = rf(ctx, request) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_ScanWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanWorkflow' +type MockClient_ScanWorkflow_Call struct { + *mock.Call +} + +// ScanWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - request *workflowservice.ScanWorkflowExecutionsRequest +func (_e *MockClient_Expecter) ScanWorkflow(ctx interface{}, request interface{}) *MockClient_ScanWorkflow_Call { + return &MockClient_ScanWorkflow_Call{Call: _e.mock.On("ScanWorkflow", ctx, request)} +} + +func (_c *MockClient_ScanWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ScanWorkflowExecutionsRequest)) *MockClient_ScanWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*workflowservice.ScanWorkflowExecutionsRequest)) + }) + return _c +} + +func (_c *MockClient_ScanWorkflow_Call) Return(_a0 *workflowservice.ScanWorkflowExecutionsResponse, _a1 error) *MockClient_ScanWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_ScanWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error)) *MockClient_ScanWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// ScheduleClient provides a mock function with given fields: +func (_m *MockClient) ScheduleClient() client.ScheduleClient { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ScheduleClient") + } + + var r0 client.ScheduleClient + if rf, ok := ret.Get(0).(func() client.ScheduleClient); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.ScheduleClient) + } + } + + return r0 +} + +// MockClient_ScheduleClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScheduleClient' +type MockClient_ScheduleClient_Call struct { + *mock.Call +} + +// ScheduleClient is a helper method to define mock.On call +func (_e *MockClient_Expecter) ScheduleClient() *MockClient_ScheduleClient_Call { + return &MockClient_ScheduleClient_Call{Call: _e.mock.On("ScheduleClient")} +} + +func (_c *MockClient_ScheduleClient_Call) Run(run func()) *MockClient_ScheduleClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockClient_ScheduleClient_Call) Return(_a0 client.ScheduleClient) *MockClient_ScheduleClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_ScheduleClient_Call) RunAndReturn(run func() client.ScheduleClient) *MockClient_ScheduleClient_Call { + _c.Call.Return(run) + return _c +} + +// SignalWithStartWorkflow provides a mock function with given fields: ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs +func (_m *MockClient) SignalWithStartWorkflow(ctx context.Context, workflowID string, signalName string, signalArg interface{}, options client.StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{}) (client.WorkflowRun, error) { + var _ca []interface{} + _ca = append(_ca, ctx, workflowID, signalName, signalArg, options, workflow) + _ca = append(_ca, workflowArgs...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SignalWithStartWorkflow") + } + + var r0 client.WorkflowRun + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)); ok { + return rf(ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) client.WorkflowRun); ok { + r0 = rf(ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WorkflowRun) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) error); ok { + r1 = rf(ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SignalWithStartWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignalWithStartWorkflow' +type MockClient_SignalWithStartWorkflow_Call struct { + *mock.Call +} + +// SignalWithStartWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - workflowID string +// - signalName string +// - signalArg interface{} +// - options client.StartWorkflowOptions +// - workflow interface{} +// - workflowArgs ...interface{} +func (_e *MockClient_Expecter) SignalWithStartWorkflow(ctx interface{}, workflowID interface{}, signalName interface{}, signalArg interface{}, options interface{}, workflow interface{}, workflowArgs ...interface{}) *MockClient_SignalWithStartWorkflow_Call { + return &MockClient_SignalWithStartWorkflow_Call{Call: _e.mock.On("SignalWithStartWorkflow", + append([]interface{}{ctx, workflowID, signalName, signalArg, options, workflow}, workflowArgs...)...)} +} + +func (_c *MockClient_SignalWithStartWorkflow_Call) Run(run func(ctx context.Context, workflowID string, signalName string, signalArg interface{}, options client.StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{})) *MockClient_SignalWithStartWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-6) + for i, a := range args[6:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(interface{}), args[4].(client.StartWorkflowOptions), args[5].(interface{}), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SignalWithStartWorkflow_Call) Return(_a0 client.WorkflowRun, _a1 error) *MockClient_SignalWithStartWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SignalWithStartWorkflow_Call) RunAndReturn(run func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)) *MockClient_SignalWithStartWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// SignalWorkflow provides a mock function with given fields: ctx, workflowID, runID, signalName, arg +func (_m *MockClient) SignalWorkflow(ctx context.Context, workflowID string, runID string, signalName string, arg interface{}) error { + ret := _m.Called(ctx, workflowID, runID, signalName, arg) + + if len(ret) == 0 { + panic("no return value specified for SignalWorkflow") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, interface{}) error); ok { + r0 = rf(ctx, workflowID, runID, signalName, arg) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_SignalWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignalWorkflow' +type MockClient_SignalWorkflow_Call struct { + *mock.Call +} + +// SignalWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - workflowID string +// - runID string +// - signalName string +// - arg interface{} +func (_e *MockClient_Expecter) SignalWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, signalName interface{}, arg interface{}) *MockClient_SignalWorkflow_Call { + return &MockClient_SignalWorkflow_Call{Call: _e.mock.On("SignalWorkflow", ctx, workflowID, runID, signalName, arg)} +} + +func (_c *MockClient_SignalWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, signalName string, arg interface{})) *MockClient_SignalWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(interface{})) + }) + return _c +} + +func (_c *MockClient_SignalWorkflow_Call) Return(_a0 error) *MockClient_SignalWorkflow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_SignalWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, interface{}) error) *MockClient_SignalWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// Start provides a mock function with given fields: +func (_m *MockClient) Start() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Start") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type MockClient_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +func (_e *MockClient_Expecter) Start() *MockClient_Start_Call { + return &MockClient_Start_Call{Call: _e.mock.On("Start")} +} + +func (_c *MockClient_Start_Call) Run(run func()) *MockClient_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockClient_Start_Call) Return(_a0 error) *MockClient_Start_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_Start_Call) RunAndReturn(run func() error) *MockClient_Start_Call { + _c.Call.Return(run) + return _c +} + +// Stop provides a mock function with given fields: +func (_m *MockClient) Stop() { + _m.Called() +} + +// MockClient_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type MockClient_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *MockClient_Expecter) Stop() *MockClient_Stop_Call { + return &MockClient_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *MockClient_Stop_Call) Run(run func()) *MockClient_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockClient_Stop_Call) Return() *MockClient_Stop_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClient_Stop_Call) RunAndReturn(run func()) *MockClient_Stop_Call { + _c.Call.Return(run) + return _c +} + +// TerminateWorkflow provides a mock function with given fields: ctx, workflowID, runID, reason, details +func (_m *MockClient) TerminateWorkflow(ctx context.Context, workflowID string, runID string, reason string, details ...interface{}) error { + var _ca []interface{} + _ca = append(_ca, ctx, workflowID, runID, reason) + _ca = append(_ca, details...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TerminateWorkflow") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, ...interface{}) error); ok { + r0 = rf(ctx, workflowID, runID, reason, details...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_TerminateWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TerminateWorkflow' +type MockClient_TerminateWorkflow_Call struct { + *mock.Call +} + +// TerminateWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - workflowID string +// - runID string +// - reason string +// - details ...interface{} +func (_e *MockClient_Expecter) TerminateWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, reason interface{}, details ...interface{}) *MockClient_TerminateWorkflow_Call { + return &MockClient_TerminateWorkflow_Call{Call: _e.mock.On("TerminateWorkflow", + append([]interface{}{ctx, workflowID, runID, reason}, details...)...)} +} + +func (_c *MockClient_TerminateWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, reason string, details ...interface{})) *MockClient_TerminateWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_TerminateWorkflow_Call) Return(_a0 error) *MockClient_TerminateWorkflow_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_TerminateWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, ...interface{}) error) *MockClient_TerminateWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// UpdateWithStartWorkflow provides a mock function with given fields: ctx, options +func (_m *MockClient) UpdateWithStartWorkflow(ctx context.Context, options client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error) { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for UpdateWithStartWorkflow") + } + + var r0 client.WorkflowUpdateHandle + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error)); ok { + return rf(ctx, options) + } + if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWithStartWorkflowOptions) client.WorkflowUpdateHandle); ok { + r0 = rf(ctx, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WorkflowUpdateHandle) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, client.UpdateWithStartWorkflowOptions) error); ok { + r1 = rf(ctx, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_UpdateWithStartWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWithStartWorkflow' +type MockClient_UpdateWithStartWorkflow_Call struct { + *mock.Call +} + +// UpdateWithStartWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - options client.UpdateWithStartWorkflowOptions +func (_e *MockClient_Expecter) UpdateWithStartWorkflow(ctx interface{}, options interface{}) *MockClient_UpdateWithStartWorkflow_Call { + return &MockClient_UpdateWithStartWorkflow_Call{Call: _e.mock.On("UpdateWithStartWorkflow", ctx, options)} +} + +func (_c *MockClient_UpdateWithStartWorkflow_Call) Run(run func(ctx context.Context, options client.UpdateWithStartWorkflowOptions)) *MockClient_UpdateWithStartWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(client.UpdateWithStartWorkflowOptions)) + }) + return _c +} + +func (_c *MockClient_UpdateWithStartWorkflow_Call) Return(_a0 client.WorkflowUpdateHandle, _a1 error) *MockClient_UpdateWithStartWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_UpdateWithStartWorkflow_Call) RunAndReturn(run func(context.Context, client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error)) *MockClient_UpdateWithStartWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// UpdateWorkerBuildIdCompatibility provides a mock function with given fields: ctx, options +func (_m *MockClient) UpdateWorkerBuildIdCompatibility(ctx context.Context, options *client.UpdateWorkerBuildIdCompatibilityOptions) error { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for UpdateWorkerBuildIdCompatibility") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *client.UpdateWorkerBuildIdCompatibilityOptions) error); ok { + r0 = rf(ctx, options) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockClient_UpdateWorkerBuildIdCompatibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkerBuildIdCompatibility' +type MockClient_UpdateWorkerBuildIdCompatibility_Call struct { + *mock.Call +} + +// UpdateWorkerBuildIdCompatibility is a helper method to define mock.On call +// - ctx context.Context +// - options *client.UpdateWorkerBuildIdCompatibilityOptions +func (_e *MockClient_Expecter) UpdateWorkerBuildIdCompatibility(ctx interface{}, options interface{}) *MockClient_UpdateWorkerBuildIdCompatibility_Call { + return &MockClient_UpdateWorkerBuildIdCompatibility_Call{Call: _e.mock.On("UpdateWorkerBuildIdCompatibility", ctx, options)} +} + +func (_c *MockClient_UpdateWorkerBuildIdCompatibility_Call) Run(run func(ctx context.Context, options *client.UpdateWorkerBuildIdCompatibilityOptions)) *MockClient_UpdateWorkerBuildIdCompatibility_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*client.UpdateWorkerBuildIdCompatibilityOptions)) + }) + return _c +} + +func (_c *MockClient_UpdateWorkerBuildIdCompatibility_Call) Return(_a0 error) *MockClient_UpdateWorkerBuildIdCompatibility_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_UpdateWorkerBuildIdCompatibility_Call) RunAndReturn(run func(context.Context, *client.UpdateWorkerBuildIdCompatibilityOptions) error) *MockClient_UpdateWorkerBuildIdCompatibility_Call { + _c.Call.Return(run) + return _c +} + +// UpdateWorkerVersioningRules provides a mock function with given fields: ctx, options +func (_m *MockClient) UpdateWorkerVersioningRules(ctx context.Context, options client.UpdateWorkerVersioningRulesOptions) (*client.WorkerVersioningRules, error) { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for UpdateWorkerVersioningRules") + } + + var r0 *client.WorkerVersioningRules + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkerVersioningRulesOptions) (*client.WorkerVersioningRules, error)); ok { + return rf(ctx, options) + } + if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkerVersioningRulesOptions) *client.WorkerVersioningRules); ok { + r0 = rf(ctx, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*client.WorkerVersioningRules) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, client.UpdateWorkerVersioningRulesOptions) error); ok { + r1 = rf(ctx, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_UpdateWorkerVersioningRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkerVersioningRules' +type MockClient_UpdateWorkerVersioningRules_Call struct { + *mock.Call +} + +// UpdateWorkerVersioningRules is a helper method to define mock.On call +// - ctx context.Context +// - options client.UpdateWorkerVersioningRulesOptions +func (_e *MockClient_Expecter) UpdateWorkerVersioningRules(ctx interface{}, options interface{}) *MockClient_UpdateWorkerVersioningRules_Call { + return &MockClient_UpdateWorkerVersioningRules_Call{Call: _e.mock.On("UpdateWorkerVersioningRules", ctx, options)} +} + +func (_c *MockClient_UpdateWorkerVersioningRules_Call) Run(run func(ctx context.Context, options client.UpdateWorkerVersioningRulesOptions)) *MockClient_UpdateWorkerVersioningRules_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(client.UpdateWorkerVersioningRulesOptions)) + }) + return _c +} + +func (_c *MockClient_UpdateWorkerVersioningRules_Call) Return(_a0 *client.WorkerVersioningRules, _a1 error) *MockClient_UpdateWorkerVersioningRules_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_UpdateWorkerVersioningRules_Call) RunAndReturn(run func(context.Context, client.UpdateWorkerVersioningRulesOptions) (*client.WorkerVersioningRules, error)) *MockClient_UpdateWorkerVersioningRules_Call { + _c.Call.Return(run) + return _c +} + +// UpdateWorkflow provides a mock function with given fields: ctx, options +func (_m *MockClient) UpdateWorkflow(ctx context.Context, options client.UpdateWorkflowOptions) (client.WorkflowUpdateHandle, error) { + ret := _m.Called(ctx, options) + + if len(ret) == 0 { + panic("no return value specified for UpdateWorkflow") + } + + var r0 client.WorkflowUpdateHandle + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkflowOptions) (client.WorkflowUpdateHandle, error)); ok { + return rf(ctx, options) + } + if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkflowOptions) client.WorkflowUpdateHandle); ok { + r0 = rf(ctx, options) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(client.WorkflowUpdateHandle) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, client.UpdateWorkflowOptions) error); ok { + r1 = rf(ctx, options) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_UpdateWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkflow' +type MockClient_UpdateWorkflow_Call struct { + *mock.Call +} + +// UpdateWorkflow is a helper method to define mock.On call +// - ctx context.Context +// - options client.UpdateWorkflowOptions +func (_e *MockClient_Expecter) UpdateWorkflow(ctx interface{}, options interface{}) *MockClient_UpdateWorkflow_Call { + return &MockClient_UpdateWorkflow_Call{Call: _e.mock.On("UpdateWorkflow", ctx, options)} +} + +func (_c *MockClient_UpdateWorkflow_Call) Run(run func(ctx context.Context, options client.UpdateWorkflowOptions)) *MockClient_UpdateWorkflow_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(client.UpdateWorkflowOptions)) + }) + return _c +} + +func (_c *MockClient_UpdateWorkflow_Call) Return(_a0 client.WorkflowUpdateHandle, _a1 error) *MockClient_UpdateWorkflow_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_UpdateWorkflow_Call) RunAndReturn(run func(context.Context, client.UpdateWorkflowOptions) (client.WorkflowUpdateHandle, error)) *MockClient_UpdateWorkflow_Call { + _c.Call.Return(run) + return _c +} + +// WorkflowService provides a mock function with given fields: +func (_m *MockClient) WorkflowService() workflowservice.WorkflowServiceClient { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for WorkflowService") + } + + var r0 workflowservice.WorkflowServiceClient + if rf, ok := ret.Get(0).(func() workflowservice.WorkflowServiceClient); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(workflowservice.WorkflowServiceClient) + } + } + + return r0 +} + +// MockClient_WorkflowService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkflowService' +type MockClient_WorkflowService_Call struct { + *mock.Call +} + +// WorkflowService is a helper method to define mock.On call +func (_e *MockClient_Expecter) WorkflowService() *MockClient_WorkflowService_Call { + return &MockClient_WorkflowService_Call{Call: _e.mock.On("WorkflowService")} +} + +func (_c *MockClient_WorkflowService_Call) Run(run func()) *MockClient_WorkflowService_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockClient_WorkflowService_Call) Return(_a0 workflowservice.WorkflowServiceClient) *MockClient_WorkflowService_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockClient_WorkflowService_Call) RunAndReturn(run func() workflowservice.WorkflowServiceClient) *MockClient_WorkflowService_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClient { + mock := &MockClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/callback/mock_GitCallbackComponent.go b/_mocks/opencsg.com/csghub-server/component/callback/mock_GitCallbackComponent.go new file mode 100644 index 00000000..3ce91d7f --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/callback/mock_GitCallbackComponent.go @@ -0,0 +1,305 @@ +// Code generated by mockery v2.49.1. DO NOT EDIT. + +package callback + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + types "opencsg.com/csghub-server/common/types" +) + +// MockGitCallbackComponent is an autogenerated mock type for the GitCallbackComponent type +type MockGitCallbackComponent struct { + mock.Mock +} + +type MockGitCallbackComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockGitCallbackComponent) EXPECT() *MockGitCallbackComponent_Expecter { + return &MockGitCallbackComponent_Expecter{mock: &_m.Mock} +} + +// SensitiveCheck provides a mock function with given fields: ctx, req +func (_m *MockGitCallbackComponent) SensitiveCheck(ctx context.Context, req *types.GiteaCallbackPushReq) error { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SensitiveCheck") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.GiteaCallbackPushReq) error); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockGitCallbackComponent_SensitiveCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SensitiveCheck' +type MockGitCallbackComponent_SensitiveCheck_Call struct { + *mock.Call +} + +// SensitiveCheck is a helper method to define mock.On call +// - ctx context.Context +// - req *types.GiteaCallbackPushReq +func (_e *MockGitCallbackComponent_Expecter) SensitiveCheck(ctx interface{}, req interface{}) *MockGitCallbackComponent_SensitiveCheck_Call { + return &MockGitCallbackComponent_SensitiveCheck_Call{Call: _e.mock.On("SensitiveCheck", ctx, req)} +} + +func (_c *MockGitCallbackComponent_SensitiveCheck_Call) Run(run func(ctx context.Context, req *types.GiteaCallbackPushReq)) *MockGitCallbackComponent_SensitiveCheck_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.GiteaCallbackPushReq)) + }) + return _c +} + +func (_c *MockGitCallbackComponent_SensitiveCheck_Call) Return(_a0 error) *MockGitCallbackComponent_SensitiveCheck_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGitCallbackComponent_SensitiveCheck_Call) RunAndReturn(run func(context.Context, *types.GiteaCallbackPushReq) error) *MockGitCallbackComponent_SensitiveCheck_Call { + _c.Call.Return(run) + return _c +} + +// SetRepoUpdateTime provides a mock function with given fields: ctx, req +func (_m *MockGitCallbackComponent) SetRepoUpdateTime(ctx context.Context, req *types.GiteaCallbackPushReq) error { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SetRepoUpdateTime") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.GiteaCallbackPushReq) error); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockGitCallbackComponent_SetRepoUpdateTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetRepoUpdateTime' +type MockGitCallbackComponent_SetRepoUpdateTime_Call struct { + *mock.Call +} + +// SetRepoUpdateTime is a helper method to define mock.On call +// - ctx context.Context +// - req *types.GiteaCallbackPushReq +func (_e *MockGitCallbackComponent_Expecter) SetRepoUpdateTime(ctx interface{}, req interface{}) *MockGitCallbackComponent_SetRepoUpdateTime_Call { + return &MockGitCallbackComponent_SetRepoUpdateTime_Call{Call: _e.mock.On("SetRepoUpdateTime", ctx, req)} +} + +func (_c *MockGitCallbackComponent_SetRepoUpdateTime_Call) Run(run func(ctx context.Context, req *types.GiteaCallbackPushReq)) *MockGitCallbackComponent_SetRepoUpdateTime_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.GiteaCallbackPushReq)) + }) + return _c +} + +func (_c *MockGitCallbackComponent_SetRepoUpdateTime_Call) Return(_a0 error) *MockGitCallbackComponent_SetRepoUpdateTime_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGitCallbackComponent_SetRepoUpdateTime_Call) RunAndReturn(run func(context.Context, *types.GiteaCallbackPushReq) error) *MockGitCallbackComponent_SetRepoUpdateTime_Call { + _c.Call.Return(run) + return _c +} + +// SetRepoVisibility provides a mock function with given fields: yes +func (_m *MockGitCallbackComponent) SetRepoVisibility(yes bool) { + _m.Called(yes) +} + +// MockGitCallbackComponent_SetRepoVisibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetRepoVisibility' +type MockGitCallbackComponent_SetRepoVisibility_Call struct { + *mock.Call +} + +// SetRepoVisibility is a helper method to define mock.On call +// - yes bool +func (_e *MockGitCallbackComponent_Expecter) SetRepoVisibility(yes interface{}) *MockGitCallbackComponent_SetRepoVisibility_Call { + return &MockGitCallbackComponent_SetRepoVisibility_Call{Call: _e.mock.On("SetRepoVisibility", yes)} +} + +func (_c *MockGitCallbackComponent_SetRepoVisibility_Call) Run(run func(yes bool)) *MockGitCallbackComponent_SetRepoVisibility_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *MockGitCallbackComponent_SetRepoVisibility_Call) Return() *MockGitCallbackComponent_SetRepoVisibility_Call { + _c.Call.Return() + return _c +} + +func (_c *MockGitCallbackComponent_SetRepoVisibility_Call) RunAndReturn(run func(bool)) *MockGitCallbackComponent_SetRepoVisibility_Call { + _c.Call.Return(run) + return _c +} + +// UpdateRepoInfos provides a mock function with given fields: ctx, req +func (_m *MockGitCallbackComponent) UpdateRepoInfos(ctx context.Context, req *types.GiteaCallbackPushReq) error { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for UpdateRepoInfos") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.GiteaCallbackPushReq) error); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockGitCallbackComponent_UpdateRepoInfos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRepoInfos' +type MockGitCallbackComponent_UpdateRepoInfos_Call struct { + *mock.Call +} + +// UpdateRepoInfos is a helper method to define mock.On call +// - ctx context.Context +// - req *types.GiteaCallbackPushReq +func (_e *MockGitCallbackComponent_Expecter) UpdateRepoInfos(ctx interface{}, req interface{}) *MockGitCallbackComponent_UpdateRepoInfos_Call { + return &MockGitCallbackComponent_UpdateRepoInfos_Call{Call: _e.mock.On("UpdateRepoInfos", ctx, req)} +} + +func (_c *MockGitCallbackComponent_UpdateRepoInfos_Call) Run(run func(ctx context.Context, req *types.GiteaCallbackPushReq)) *MockGitCallbackComponent_UpdateRepoInfos_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.GiteaCallbackPushReq)) + }) + return _c +} + +func (_c *MockGitCallbackComponent_UpdateRepoInfos_Call) Return(_a0 error) *MockGitCallbackComponent_UpdateRepoInfos_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGitCallbackComponent_UpdateRepoInfos_Call) RunAndReturn(run func(context.Context, *types.GiteaCallbackPushReq) error) *MockGitCallbackComponent_UpdateRepoInfos_Call { + _c.Call.Return(run) + return _c +} + +// WatchRepoRelation provides a mock function with given fields: ctx, req +func (_m *MockGitCallbackComponent) WatchRepoRelation(ctx context.Context, req *types.GiteaCallbackPushReq) error { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for WatchRepoRelation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.GiteaCallbackPushReq) error); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockGitCallbackComponent_WatchRepoRelation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchRepoRelation' +type MockGitCallbackComponent_WatchRepoRelation_Call struct { + *mock.Call +} + +// WatchRepoRelation is a helper method to define mock.On call +// - ctx context.Context +// - req *types.GiteaCallbackPushReq +func (_e *MockGitCallbackComponent_Expecter) WatchRepoRelation(ctx interface{}, req interface{}) *MockGitCallbackComponent_WatchRepoRelation_Call { + return &MockGitCallbackComponent_WatchRepoRelation_Call{Call: _e.mock.On("WatchRepoRelation", ctx, req)} +} + +func (_c *MockGitCallbackComponent_WatchRepoRelation_Call) Run(run func(ctx context.Context, req *types.GiteaCallbackPushReq)) *MockGitCallbackComponent_WatchRepoRelation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.GiteaCallbackPushReq)) + }) + return _c +} + +func (_c *MockGitCallbackComponent_WatchRepoRelation_Call) Return(_a0 error) *MockGitCallbackComponent_WatchRepoRelation_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGitCallbackComponent_WatchRepoRelation_Call) RunAndReturn(run func(context.Context, *types.GiteaCallbackPushReq) error) *MockGitCallbackComponent_WatchRepoRelation_Call { + _c.Call.Return(run) + return _c +} + +// WatchSpaceChange provides a mock function with given fields: ctx, req +func (_m *MockGitCallbackComponent) WatchSpaceChange(ctx context.Context, req *types.GiteaCallbackPushReq) error { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for WatchSpaceChange") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.GiteaCallbackPushReq) error); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockGitCallbackComponent_WatchSpaceChange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WatchSpaceChange' +type MockGitCallbackComponent_WatchSpaceChange_Call struct { + *mock.Call +} + +// WatchSpaceChange is a helper method to define mock.On call +// - ctx context.Context +// - req *types.GiteaCallbackPushReq +func (_e *MockGitCallbackComponent_Expecter) WatchSpaceChange(ctx interface{}, req interface{}) *MockGitCallbackComponent_WatchSpaceChange_Call { + return &MockGitCallbackComponent_WatchSpaceChange_Call{Call: _e.mock.On("WatchSpaceChange", ctx, req)} +} + +func (_c *MockGitCallbackComponent_WatchSpaceChange_Call) Run(run func(ctx context.Context, req *types.GiteaCallbackPushReq)) *MockGitCallbackComponent_WatchSpaceChange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.GiteaCallbackPushReq)) + }) + return _c +} + +func (_c *MockGitCallbackComponent_WatchSpaceChange_Call) Return(_a0 error) *MockGitCallbackComponent_WatchSpaceChange_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGitCallbackComponent_WatchSpaceChange_Call) RunAndReturn(run func(context.Context, *types.GiteaCallbackPushReq) error) *MockGitCallbackComponent_WatchSpaceChange_Call { + _c.Call.Return(run) + return _c +} + +// NewMockGitCallbackComponent creates a new instance of MockGitCallbackComponent. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockGitCallbackComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockGitCallbackComponent { + mock := &MockGitCallbackComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/mock_MultiSyncComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_MultiSyncComponent.go new file mode 100644 index 00000000..64593c06 --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_MultiSyncComponent.go @@ -0,0 +1,146 @@ +// Code generated by mockery v2.49.1. DO NOT EDIT. + +package component + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + multisync "opencsg.com/csghub-server/builder/multisync" + + types "opencsg.com/csghub-server/common/types" +) + +// MockMultiSyncComponent is an autogenerated mock type for the MultiSyncComponent type +type MockMultiSyncComponent struct { + mock.Mock +} + +type MockMultiSyncComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockMultiSyncComponent) EXPECT() *MockMultiSyncComponent_Expecter { + return &MockMultiSyncComponent_Expecter{mock: &_m.Mock} +} + +// More provides a mock function with given fields: ctx, cur, limit +func (_m *MockMultiSyncComponent) More(ctx context.Context, cur int64, limit int64) ([]types.SyncVersion, error) { + ret := _m.Called(ctx, cur, limit) + + if len(ret) == 0 { + panic("no return value specified for More") + } + + var r0 []types.SyncVersion + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, int64, int64) ([]types.SyncVersion, error)); ok { + return rf(ctx, cur, limit) + } + if rf, ok := ret.Get(0).(func(context.Context, int64, int64) []types.SyncVersion); ok { + r0 = rf(ctx, cur, limit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]types.SyncVersion) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, int64, int64) error); ok { + r1 = rf(ctx, cur, limit) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockMultiSyncComponent_More_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'More' +type MockMultiSyncComponent_More_Call struct { + *mock.Call +} + +// More is a helper method to define mock.On call +// - ctx context.Context +// - cur int64 +// - limit int64 +func (_e *MockMultiSyncComponent_Expecter) More(ctx interface{}, cur interface{}, limit interface{}) *MockMultiSyncComponent_More_Call { + return &MockMultiSyncComponent_More_Call{Call: _e.mock.On("More", ctx, cur, limit)} +} + +func (_c *MockMultiSyncComponent_More_Call) Run(run func(ctx context.Context, cur int64, limit int64)) *MockMultiSyncComponent_More_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(int64)) + }) + return _c +} + +func (_c *MockMultiSyncComponent_More_Call) Return(_a0 []types.SyncVersion, _a1 error) *MockMultiSyncComponent_More_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockMultiSyncComponent_More_Call) RunAndReturn(run func(context.Context, int64, int64) ([]types.SyncVersion, error)) *MockMultiSyncComponent_More_Call { + _c.Call.Return(run) + return _c +} + +// SyncAsClient provides a mock function with given fields: ctx, sc +func (_m *MockMultiSyncComponent) SyncAsClient(ctx context.Context, sc multisync.Client) error { + ret := _m.Called(ctx, sc) + + if len(ret) == 0 { + panic("no return value specified for SyncAsClient") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, multisync.Client) error); ok { + r0 = rf(ctx, sc) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockMultiSyncComponent_SyncAsClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncAsClient' +type MockMultiSyncComponent_SyncAsClient_Call struct { + *mock.Call +} + +// SyncAsClient is a helper method to define mock.On call +// - ctx context.Context +// - sc multisync.Client +func (_e *MockMultiSyncComponent_Expecter) SyncAsClient(ctx interface{}, sc interface{}) *MockMultiSyncComponent_SyncAsClient_Call { + return &MockMultiSyncComponent_SyncAsClient_Call{Call: _e.mock.On("SyncAsClient", ctx, sc)} +} + +func (_c *MockMultiSyncComponent_SyncAsClient_Call) Run(run func(ctx context.Context, sc multisync.Client)) *MockMultiSyncComponent_SyncAsClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(multisync.Client)) + }) + return _c +} + +func (_c *MockMultiSyncComponent_SyncAsClient_Call) Return(_a0 error) *MockMultiSyncComponent_SyncAsClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMultiSyncComponent_SyncAsClient_Call) RunAndReturn(run func(context.Context, multisync.Client) error) *MockMultiSyncComponent_SyncAsClient_Call { + _c.Call.Return(run) + return _c +} + +// NewMockMultiSyncComponent creates a new instance of MockMultiSyncComponent. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockMultiSyncComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockMultiSyncComponent { + mock := &MockMultiSyncComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/mock_RecomComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_RecomComponent.go new file mode 100644 index 00000000..91dad12d --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_RecomComponent.go @@ -0,0 +1,166 @@ +// Code generated by mockery v2.49.1. DO NOT EDIT. + +package component + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + database "opencsg.com/csghub-server/builder/store/database" +) + +// MockRecomComponent is an autogenerated mock type for the RecomComponent type +type MockRecomComponent struct { + mock.Mock +} + +type MockRecomComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRecomComponent) EXPECT() *MockRecomComponent_Expecter { + return &MockRecomComponent_Expecter{mock: &_m.Mock} +} + +// CalcTotalScore provides a mock function with given fields: ctx, repo, weights +func (_m *MockRecomComponent) CalcTotalScore(ctx context.Context, repo *database.Repository, weights map[string]string) float64 { + ret := _m.Called(ctx, repo, weights) + + if len(ret) == 0 { + panic("no return value specified for CalcTotalScore") + } + + var r0 float64 + if rf, ok := ret.Get(0).(func(context.Context, *database.Repository, map[string]string) float64); ok { + r0 = rf(ctx, repo, weights) + } else { + r0 = ret.Get(0).(float64) + } + + return r0 +} + +// MockRecomComponent_CalcTotalScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CalcTotalScore' +type MockRecomComponent_CalcTotalScore_Call struct { + *mock.Call +} + +// CalcTotalScore is a helper method to define mock.On call +// - ctx context.Context +// - repo *database.Repository +// - weights map[string]string +func (_e *MockRecomComponent_Expecter) CalcTotalScore(ctx interface{}, repo interface{}, weights interface{}) *MockRecomComponent_CalcTotalScore_Call { + return &MockRecomComponent_CalcTotalScore_Call{Call: _e.mock.On("CalcTotalScore", ctx, repo, weights)} +} + +func (_c *MockRecomComponent_CalcTotalScore_Call) Run(run func(ctx context.Context, repo *database.Repository, weights map[string]string)) *MockRecomComponent_CalcTotalScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*database.Repository), args[2].(map[string]string)) + }) + return _c +} + +func (_c *MockRecomComponent_CalcTotalScore_Call) Return(_a0 float64) *MockRecomComponent_CalcTotalScore_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockRecomComponent_CalcTotalScore_Call) RunAndReturn(run func(context.Context, *database.Repository, map[string]string) float64) *MockRecomComponent_CalcTotalScore_Call { + _c.Call.Return(run) + return _c +} + +// CalculateRecomScore provides a mock function with given fields: ctx +func (_m *MockRecomComponent) CalculateRecomScore(ctx context.Context) { + _m.Called(ctx) +} + +// MockRecomComponent_CalculateRecomScore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CalculateRecomScore' +type MockRecomComponent_CalculateRecomScore_Call struct { + *mock.Call +} + +// CalculateRecomScore is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockRecomComponent_Expecter) CalculateRecomScore(ctx interface{}) *MockRecomComponent_CalculateRecomScore_Call { + return &MockRecomComponent_CalculateRecomScore_Call{Call: _e.mock.On("CalculateRecomScore", ctx)} +} + +func (_c *MockRecomComponent_CalculateRecomScore_Call) Run(run func(ctx context.Context)) *MockRecomComponent_CalculateRecomScore_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockRecomComponent_CalculateRecomScore_Call) Return() *MockRecomComponent_CalculateRecomScore_Call { + _c.Call.Return() + return _c +} + +func (_c *MockRecomComponent_CalculateRecomScore_Call) RunAndReturn(run func(context.Context)) *MockRecomComponent_CalculateRecomScore_Call { + _c.Call.Return(run) + return _c +} + +// SetOpWeight provides a mock function with given fields: ctx, repoID, weight +func (_m *MockRecomComponent) SetOpWeight(ctx context.Context, repoID int64, weight int64) error { + ret := _m.Called(ctx, repoID, weight) + + if len(ret) == 0 { + panic("no return value specified for SetOpWeight") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, int64, int64) error); ok { + r0 = rf(ctx, repoID, weight) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockRecomComponent_SetOpWeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOpWeight' +type MockRecomComponent_SetOpWeight_Call struct { + *mock.Call +} + +// SetOpWeight is a helper method to define mock.On call +// - ctx context.Context +// - repoID int64 +// - weight int64 +func (_e *MockRecomComponent_Expecter) SetOpWeight(ctx interface{}, repoID interface{}, weight interface{}) *MockRecomComponent_SetOpWeight_Call { + return &MockRecomComponent_SetOpWeight_Call{Call: _e.mock.On("SetOpWeight", ctx, repoID, weight)} +} + +func (_c *MockRecomComponent_SetOpWeight_Call) Run(run func(ctx context.Context, repoID int64, weight int64)) *MockRecomComponent_SetOpWeight_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(int64)) + }) + return _c +} + +func (_c *MockRecomComponent_SetOpWeight_Call) Return(_a0 error) *MockRecomComponent_SetOpWeight_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockRecomComponent_SetOpWeight_Call) RunAndReturn(run func(context.Context, int64, int64) error) *MockRecomComponent_SetOpWeight_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRecomComponent creates a new instance of MockRecomComponent. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRecomComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockRecomComponent { + mock := &MockRecomComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/user/component/mock_OrganizationComponent.go b/_mocks/opencsg.com/csghub-server/user/component/mock_OrganizationComponent.go new file mode 100644 index 00000000..3640b555 --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/user/component/mock_OrganizationComponent.go @@ -0,0 +1,381 @@ +// Code generated by mockery v2.49.1. DO NOT EDIT. + +package component + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + database "opencsg.com/csghub-server/builder/store/database" + + types "opencsg.com/csghub-server/common/types" +) + +// MockOrganizationComponent is an autogenerated mock type for the OrganizationComponent type +type MockOrganizationComponent struct { + mock.Mock +} + +type MockOrganizationComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockOrganizationComponent) EXPECT() *MockOrganizationComponent_Expecter { + return &MockOrganizationComponent_Expecter{mock: &_m.Mock} +} + +// Create provides a mock function with given fields: ctx, req +func (_m *MockOrganizationComponent) Create(ctx context.Context, req *types.CreateOrgReq) (*types.Organization, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + var r0 *types.Organization + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *types.CreateOrgReq) (*types.Organization, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *types.CreateOrgReq) *types.Organization); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.Organization) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *types.CreateOrgReq) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockOrganizationComponent_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type MockOrganizationComponent_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - req *types.CreateOrgReq +func (_e *MockOrganizationComponent_Expecter) Create(ctx interface{}, req interface{}) *MockOrganizationComponent_Create_Call { + return &MockOrganizationComponent_Create_Call{Call: _e.mock.On("Create", ctx, req)} +} + +func (_c *MockOrganizationComponent_Create_Call) Run(run func(ctx context.Context, req *types.CreateOrgReq)) *MockOrganizationComponent_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.CreateOrgReq)) + }) + return _c +} + +func (_c *MockOrganizationComponent_Create_Call) Return(_a0 *types.Organization, _a1 error) *MockOrganizationComponent_Create_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockOrganizationComponent_Create_Call) RunAndReturn(run func(context.Context, *types.CreateOrgReq) (*types.Organization, error)) *MockOrganizationComponent_Create_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, req +func (_m *MockOrganizationComponent) Delete(ctx context.Context, req *types.DeleteOrgReq) error { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.DeleteOrgReq) error); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockOrganizationComponent_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockOrganizationComponent_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - req *types.DeleteOrgReq +func (_e *MockOrganizationComponent_Expecter) Delete(ctx interface{}, req interface{}) *MockOrganizationComponent_Delete_Call { + return &MockOrganizationComponent_Delete_Call{Call: _e.mock.On("Delete", ctx, req)} +} + +func (_c *MockOrganizationComponent_Delete_Call) Run(run func(ctx context.Context, req *types.DeleteOrgReq)) *MockOrganizationComponent_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.DeleteOrgReq)) + }) + return _c +} + +func (_c *MockOrganizationComponent_Delete_Call) Return(_a0 error) *MockOrganizationComponent_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockOrganizationComponent_Delete_Call) RunAndReturn(run func(context.Context, *types.DeleteOrgReq) error) *MockOrganizationComponent_Delete_Call { + _c.Call.Return(run) + return _c +} + +// FixOrgData provides a mock function with given fields: ctx, org +func (_m *MockOrganizationComponent) FixOrgData(ctx context.Context, org *database.Organization) (*database.Organization, error) { + ret := _m.Called(ctx, org) + + if len(ret) == 0 { + panic("no return value specified for FixOrgData") + } + + var r0 *database.Organization + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *database.Organization) (*database.Organization, error)); ok { + return rf(ctx, org) + } + if rf, ok := ret.Get(0).(func(context.Context, *database.Organization) *database.Organization); ok { + r0 = rf(ctx, org) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*database.Organization) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *database.Organization) error); ok { + r1 = rf(ctx, org) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockOrganizationComponent_FixOrgData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FixOrgData' +type MockOrganizationComponent_FixOrgData_Call struct { + *mock.Call +} + +// FixOrgData is a helper method to define mock.On call +// - ctx context.Context +// - org *database.Organization +func (_e *MockOrganizationComponent_Expecter) FixOrgData(ctx interface{}, org interface{}) *MockOrganizationComponent_FixOrgData_Call { + return &MockOrganizationComponent_FixOrgData_Call{Call: _e.mock.On("FixOrgData", ctx, org)} +} + +func (_c *MockOrganizationComponent_FixOrgData_Call) Run(run func(ctx context.Context, org *database.Organization)) *MockOrganizationComponent_FixOrgData_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*database.Organization)) + }) + return _c +} + +func (_c *MockOrganizationComponent_FixOrgData_Call) Return(_a0 *database.Organization, _a1 error) *MockOrganizationComponent_FixOrgData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockOrganizationComponent_FixOrgData_Call) RunAndReturn(run func(context.Context, *database.Organization) (*database.Organization, error)) *MockOrganizationComponent_FixOrgData_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: ctx, orgName +func (_m *MockOrganizationComponent) Get(ctx context.Context, orgName string) (*types.Organization, error) { + ret := _m.Called(ctx, orgName) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 *types.Organization + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (*types.Organization, error)); ok { + return rf(ctx, orgName) + } + if rf, ok := ret.Get(0).(func(context.Context, string) *types.Organization); ok { + r0 = rf(ctx, orgName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.Organization) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, orgName) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockOrganizationComponent_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockOrganizationComponent_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - orgName string +func (_e *MockOrganizationComponent_Expecter) Get(ctx interface{}, orgName interface{}) *MockOrganizationComponent_Get_Call { + return &MockOrganizationComponent_Get_Call{Call: _e.mock.On("Get", ctx, orgName)} +} + +func (_c *MockOrganizationComponent_Get_Call) Run(run func(ctx context.Context, orgName string)) *MockOrganizationComponent_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockOrganizationComponent_Get_Call) Return(_a0 *types.Organization, _a1 error) *MockOrganizationComponent_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockOrganizationComponent_Get_Call) RunAndReturn(run func(context.Context, string) (*types.Organization, error)) *MockOrganizationComponent_Get_Call { + _c.Call.Return(run) + return _c +} + +// Index provides a mock function with given fields: ctx, username +func (_m *MockOrganizationComponent) Index(ctx context.Context, username string) ([]types.Organization, error) { + ret := _m.Called(ctx, username) + + if len(ret) == 0 { + panic("no return value specified for Index") + } + + var r0 []types.Organization + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) ([]types.Organization, error)); ok { + return rf(ctx, username) + } + if rf, ok := ret.Get(0).(func(context.Context, string) []types.Organization); ok { + r0 = rf(ctx, username) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]types.Organization) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, username) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockOrganizationComponent_Index_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Index' +type MockOrganizationComponent_Index_Call struct { + *mock.Call +} + +// Index is a helper method to define mock.On call +// - ctx context.Context +// - username string +func (_e *MockOrganizationComponent_Expecter) Index(ctx interface{}, username interface{}) *MockOrganizationComponent_Index_Call { + return &MockOrganizationComponent_Index_Call{Call: _e.mock.On("Index", ctx, username)} +} + +func (_c *MockOrganizationComponent_Index_Call) Run(run func(ctx context.Context, username string)) *MockOrganizationComponent_Index_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockOrganizationComponent_Index_Call) Return(_a0 []types.Organization, _a1 error) *MockOrganizationComponent_Index_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockOrganizationComponent_Index_Call) RunAndReturn(run func(context.Context, string) ([]types.Organization, error)) *MockOrganizationComponent_Index_Call { + _c.Call.Return(run) + return _c +} + +// Update provides a mock function with given fields: ctx, req +func (_m *MockOrganizationComponent) Update(ctx context.Context, req *types.EditOrgReq) (*database.Organization, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for Update") + } + + var r0 *database.Organization + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *types.EditOrgReq) (*database.Organization, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *types.EditOrgReq) *database.Organization); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*database.Organization) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *types.EditOrgReq) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockOrganizationComponent_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type MockOrganizationComponent_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - ctx context.Context +// - req *types.EditOrgReq +func (_e *MockOrganizationComponent_Expecter) Update(ctx interface{}, req interface{}) *MockOrganizationComponent_Update_Call { + return &MockOrganizationComponent_Update_Call{Call: _e.mock.On("Update", ctx, req)} +} + +func (_c *MockOrganizationComponent_Update_Call) Run(run func(ctx context.Context, req *types.EditOrgReq)) *MockOrganizationComponent_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.EditOrgReq)) + }) + return _c +} + +func (_c *MockOrganizationComponent_Update_Call) Return(_a0 *database.Organization, _a1 error) *MockOrganizationComponent_Update_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockOrganizationComponent_Update_Call) RunAndReturn(run func(context.Context, *types.EditOrgReq) (*database.Organization, error)) *MockOrganizationComponent_Update_Call { + _c.Call.Return(run) + return _c +} + +// NewMockOrganizationComponent creates a new instance of MockOrganizationComponent. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockOrganizationComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockOrganizationComponent { + mock := &MockOrganizationComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/api/handler/callback/git_callback.go b/api/handler/callback/git_callback.go index 1fda23f8..c21e7555 100644 --- a/api/handler/callback/git_callback.go +++ b/api/handler/callback/git_callback.go @@ -8,6 +8,7 @@ import ( "go.temporal.io/sdk/client" "opencsg.com/csghub-server/api/httpbase" "opencsg.com/csghub-server/api/workflow" + "opencsg.com/csghub-server/builder/temporal" "opencsg.com/csghub-server/common/config" "opencsg.com/csghub-server/common/types" component "opencsg.com/csghub-server/component/callback" @@ -48,14 +49,13 @@ func (h *GitCallbackHandler) handlePush(c *gin.Context) { return } //start workflow to handle push request - workflowClient := workflow.GetWorkflowClient() + workflowClient := temporal.GetClient() workflowOptions := client.StartWorkflowOptions{ TaskQueue: workflow.HandlePushQueueName, } - we, err := workflowClient.ExecuteWorkflow(c, workflowOptions, workflow.HandlePushWorkflow, - &req, - h.config, + we, err := workflowClient.ExecuteWorkflow( + c, workflowOptions, workflow.HandlePushWorkflow, &req, ) if err != nil { slog.Error("failed to handle git push callback", slog.Any("error", err)) diff --git a/api/handler/internal.go b/api/handler/internal.go index 12ada5cc..2c66efe8 100644 --- a/api/handler/internal.go +++ b/api/handler/internal.go @@ -9,6 +9,7 @@ import ( "go.temporal.io/sdk/client" "opencsg.com/csghub-server/api/httpbase" "opencsg.com/csghub-server/api/workflow" + "opencsg.com/csghub-server/builder/temporal" "opencsg.com/csghub-server/common/config" "opencsg.com/csghub-server/common/types" "opencsg.com/csghub-server/component" @@ -22,14 +23,14 @@ func NewInternalHandler(config *config.Config) (*InternalHandler, error) { return &InternalHandler{ internal: uc, config: config, - workflowClient: workflow.GetWorkflowClient(), + temporalClient: temporal.GetClient(), }, nil } type InternalHandler struct { internal component.InternalComponent config *config.Config - workflowClient client.Client + temporalClient temporal.Client } // TODO: add prmission check @@ -138,14 +139,12 @@ func (h *InternalHandler) PostReceive(ctx *gin.Context) { } callback.Ref = originalRef //start workflow to handle push request - workflowClient := h.workflowClient workflowOptions := client.StartWorkflowOptions{ TaskQueue: workflow.HandlePushQueueName, } - we, err := workflowClient.ExecuteWorkflow(ctx, workflowOptions, workflow.HandlePushWorkflow, - callback, - h.config, + we, err := h.temporalClient.ExecuteWorkflow( + ctx, workflowOptions, workflow.HandlePushWorkflow, callback, ) if err != nil { slog.Error("failed to handle git push callback", slog.Any("error", err)) diff --git a/api/handler/internal_test.go b/api/handler/internal_test.go index 82446dbe..5ff19e2f 100644 --- a/api/handler/internal_test.go +++ b/api/handler/internal_test.go @@ -7,7 +7,7 @@ import ( "github.com/stretchr/testify/mock" "go.temporal.io/sdk/client" temporal_mock "go.temporal.io/sdk/mocks" - mock_temporal "opencsg.com/csghub-server/_mocks/go.temporal.io/sdk/client" + workflow_mock "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/temporal" mockcomponent "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/component" "opencsg.com/csghub-server/api/workflow" "opencsg.com/csghub-server/builder/store/database" @@ -19,19 +19,19 @@ type InternalTester struct { *GinTester handler *InternalHandler mocks struct { - internal *mockcomponent.MockInternalComponent - workflowClient *mock_temporal.MockClient + internal *mockcomponent.MockInternalComponent + workflow *workflow_mock.MockClient } } func NewInternalTester(t *testing.T) *InternalTester { tester := &InternalTester{GinTester: NewGinTester()} tester.mocks.internal = mockcomponent.NewMockInternalComponent(t) - tester.mocks.workflowClient = mock_temporal.NewMockClient(t) + tester.mocks.workflow = workflow_mock.NewMockClient(t) tester.handler = &InternalHandler{ internal: tester.mocks.internal, - workflowClient: tester.mocks.workflowClient, + temporalClient: tester.mocks.workflow, config: &config.Config{}, } tester.WithParam("internalId", "testInternalId") @@ -149,11 +149,11 @@ func TestInternalHandler_PostReceive(t *testing.T) { runMock := &temporal_mock.WorkflowRun{} runMock.On("GetID").Return("id") - tester.mocks.workflowClient.EXPECT().ExecuteWorkflow( + tester.mocks.workflow.EXPECT().ExecuteWorkflow( tester.ctx, client.StartWorkflowOptions{ TaskQueue: workflow.HandlePushQueueName, }, mock.Anything, - &types.GiteaCallbackPushReq{Ref: "ref/heads/main"}, &config.Config{}, + &types.GiteaCallbackPushReq{Ref: "ref/heads/main"}, ).Return( runMock, nil, ) diff --git a/api/workflow/activity/activities_ce.go b/api/workflow/activity/activities_ce.go new file mode 100644 index 00000000..8cc27961 --- /dev/null +++ b/api/workflow/activity/activities_ce.go @@ -0,0 +1,46 @@ +//go:build !ee && !saas + +package activity + +import ( + "opencsg.com/csghub-server/builder/git/gitserver" + "opencsg.com/csghub-server/builder/store/database" + "opencsg.com/csghub-server/common/config" + "opencsg.com/csghub-server/component" + "opencsg.com/csghub-server/component/callback" +) + +type stores struct { + syncClientSetting database.SyncClientSettingStore +} + +type Activities struct { + config *config.Config + callback callback.GitCallbackComponent + recom component.RecomComponent + gitServer gitserver.GitServer + multisync component.MultiSyncComponent + stores stores +} + +func NewActivities( + cfg *config.Config, + callback callback.GitCallbackComponent, + recom component.RecomComponent, + gitServer gitserver.GitServer, + multisync component.MultiSyncComponent, + syncClientSetting database.SyncClientSettingStore, +) *Activities { + stores := stores{ + syncClientSetting: syncClientSetting, + } + + return &Activities{ + config: cfg, + callback: callback, + recom: recom, + gitServer: gitServer, + multisync: multisync, + stores: stores, + } +} diff --git a/api/workflow/activity/calc_recom_score.go b/api/workflow/activity/calc_recom_score.go index a2704f60..e11df67f 100644 --- a/api/workflow/activity/calc_recom_score.go +++ b/api/workflow/activity/calc_recom_score.go @@ -2,18 +2,9 @@ package activity import ( "context" - "log/slog" - - "opencsg.com/csghub-server/common/config" - "opencsg.com/csghub-server/component" ) -func CalcRecomScore(ctx context.Context, config *config.Config) error { - c, err := component.NewRecomComponent(config) - if err != nil { - slog.Error("failed to create recom component", "err", err) - return err - } - c.CalculateRecomScore(context.Background()) +func (a *Activities) CalcRecomScore(ctx context.Context) error { + a.recom.CalculateRecomScore(context.Background()) return nil } diff --git a/api/workflow/activity/handle_push.go b/api/workflow/activity/handle_push.go index 112e7a16..2a1171d3 100644 --- a/api/workflow/activity/handle_push.go +++ b/api/workflow/activity/handle_push.go @@ -2,65 +2,42 @@ package activity import ( "context" - "fmt" "go.temporal.io/sdk/activity" - "opencsg.com/csghub-server/common/config" "opencsg.com/csghub-server/common/types" - "opencsg.com/csghub-server/component/callback" ) -func WatchSpaceChange(ctx context.Context, req *types.GiteaCallbackPushReq, config *config.Config) error { +func (a *Activities) WatchSpaceChange(ctx context.Context, req *types.GiteaCallbackPushReq) error { logger := activity.GetLogger(ctx) logger.Info("watch space change start", "req", req) - callbackComponent, err := callback.NewGitCallback(config) - if err != nil { - return fmt.Errorf("failed to create callback component, error: %w", err) - } - callbackComponent.SetRepoVisibility(true) - return callbackComponent.WatchSpaceChange(ctx, req) + a.callback.SetRepoVisibility(true) + return a.callback.WatchSpaceChange(ctx, req) } -func WatchRepoRelation(ctx context.Context, req *types.GiteaCallbackPushReq, config *config.Config) error { +func (a *Activities) WatchRepoRelation(ctx context.Context, req *types.GiteaCallbackPushReq) error { logger := activity.GetLogger(ctx) logger.Info("watch repo relation start", "req", req) - callbackComponent, err := callback.NewGitCallback(config) - if err != nil { - return fmt.Errorf("failed to create callback component, error: %w", err) - } - callbackComponent.SetRepoVisibility(true) - return callbackComponent.WatchRepoRelation(ctx, req) + a.callback.SetRepoVisibility(true) + return a.callback.WatchRepoRelation(ctx, req) } -func SetRepoUpdateTime(ctx context.Context, req *types.GiteaCallbackPushReq, config *config.Config) error { +func (a *Activities) SetRepoUpdateTime(ctx context.Context, req *types.GiteaCallbackPushReq) error { logger := activity.GetLogger(ctx) logger.Info("set repo update time start", "req", req) - callbackComponent, err := callback.NewGitCallback(config) - if err != nil { - return fmt.Errorf("failed to create callback component, error: %w", err) - } - callbackComponent.SetRepoVisibility(true) - return callbackComponent.SetRepoUpdateTime(ctx, req) + a.callback.SetRepoVisibility(true) + return a.callback.SetRepoUpdateTime(ctx, req) } -func UpdateRepoInfos(ctx context.Context, req *types.GiteaCallbackPushReq, config *config.Config) error { +func (a *Activities) UpdateRepoInfos(ctx context.Context, req *types.GiteaCallbackPushReq) error { logger := activity.GetLogger(ctx) logger.Info("update repo infos start", "req", req) - callbackComponent, err := callback.NewGitCallback(config) - if err != nil { - return fmt.Errorf("failed to create callback component, error: %w", err) - } - callbackComponent.SetRepoVisibility(true) - return callbackComponent.UpdateRepoInfos(ctx, req) + a.callback.SetRepoVisibility(true) + return a.callback.UpdateRepoInfos(ctx, req) } -func SensitiveCheck(ctx context.Context, req *types.GiteaCallbackPushReq, config *config.Config) error { +func (a *Activities) SensitiveCheck(ctx context.Context, req *types.GiteaCallbackPushReq) error { logger := activity.GetLogger(ctx) logger.Info("sensitive check start", "req", req) - callbackComponent, err := callback.NewGitCallback(config) - if err != nil { - return fmt.Errorf("failed to create callback component, error: %w", err) - } - callbackComponent.SetRepoVisibility(true) - return callbackComponent.SensitiveCheck(ctx, req) + a.callback.SetRepoVisibility(true) + return a.callback.SensitiveCheck(ctx, req) } diff --git a/api/workflow/activity/sync_as_client.go b/api/workflow/activity/sync_as_client.go index 99e4ca3e..92652ae2 100644 --- a/api/workflow/activity/sync_as_client.go +++ b/api/workflow/activity/sync_as_client.go @@ -5,24 +5,15 @@ import ( "log/slog" "opencsg.com/csghub-server/builder/multisync" - "opencsg.com/csghub-server/builder/store/database" - "opencsg.com/csghub-server/common/config" - "opencsg.com/csghub-server/component" ) -func SyncAsClient(ctx context.Context, config *config.Config) error { - c, err := component.NewMultiSyncComponent(config) - if err != nil { - slog.Error("failed to create multi sync component", "err", err) - return err - } - syncClientSettingStore := database.NewSyncClientSettingStore() - setting, err := syncClientSettingStore.First(ctx) +func (a *Activities) SyncAsClient(ctx context.Context) error { + setting, err := a.stores.syncClientSetting.First(ctx) if err != nil { slog.Error("failed to find sync client setting", "error", err) return err } - apiDomain := config.MultiSync.SaasAPIDomain + apiDomain := a.config.MultiSync.SaasAPIDomain sc := multisync.FromOpenCSG(apiDomain, setting.Token) - return c.SyncAsClient(ctx, sc) + return a.multisync.SyncAsClient(ctx, sc) } diff --git a/api/workflow/cron_calc_recom_score.go b/api/workflow/cron_calc_recom_score.go index d6c44fab..293a54e6 100644 --- a/api/workflow/cron_calc_recom_score.go +++ b/api/workflow/cron_calc_recom_score.go @@ -5,11 +5,9 @@ import ( "go.temporal.io/sdk/temporal" "go.temporal.io/sdk/workflow" - "opencsg.com/csghub-server/api/workflow/activity" - "opencsg.com/csghub-server/common/config" ) -func CalcRecomScoreWorkflow(ctx workflow.Context, config *config.Config) error { +func CalcRecomScoreWorkflow(ctx workflow.Context) error { logger := workflow.GetLogger(ctx) logger.Info("calc recom score workflow started") @@ -23,7 +21,7 @@ func CalcRecomScoreWorkflow(ctx workflow.Context, config *config.Config) error { } ctx = workflow.WithActivityOptions(ctx, options) - err := workflow.ExecuteActivity(ctx, activity.CalcRecomScore, config).Get(ctx, nil) + err := workflow.ExecuteActivity(ctx, activities.CalcRecomScore).Get(ctx, nil) if err != nil { logger.Error("failed to calc recom score", "error", err) return err diff --git a/api/workflow/cron_sync_as_client.go b/api/workflow/cron_sync_as_client.go index 54f5ab6b..1c200a49 100644 --- a/api/workflow/cron_sync_as_client.go +++ b/api/workflow/cron_sync_as_client.go @@ -5,11 +5,9 @@ import ( "go.temporal.io/sdk/temporal" "go.temporal.io/sdk/workflow" - "opencsg.com/csghub-server/api/workflow/activity" - "opencsg.com/csghub-server/common/config" ) -func SyncAsClientWorkflow(ctx workflow.Context, config *config.Config) error { +func SyncAsClientWorkflow(ctx workflow.Context) error { logger := workflow.GetLogger(ctx) logger.Info("sync as client workflow started") @@ -23,7 +21,7 @@ func SyncAsClientWorkflow(ctx workflow.Context, config *config.Config) error { } ctx = workflow.WithActivityOptions(ctx, options) - err := workflow.ExecuteActivity(ctx, activity.SyncAsClient, config).Get(ctx, nil) + err := workflow.ExecuteActivity(ctx, activities.SyncAsClient).Get(ctx, nil) if err != nil { logger.Error("failed to sync as client", "error", err) return err diff --git a/api/workflow/cron_worker.go b/api/workflow/cron_worker.go index b0409c12..7ba1c348 100644 --- a/api/workflow/cron_worker.go +++ b/api/workflow/cron_worker.go @@ -1,88 +1,6 @@ package workflow -import ( - "context" - "fmt" - - enumspb "go.temporal.io/api/enums/v1" - "go.temporal.io/sdk/client" - "go.temporal.io/sdk/worker" - "opencsg.com/csghub-server/api/workflow/activity" - "opencsg.com/csghub-server/common/config" -) - const ( AlreadyScheduledMessage = "schedule with this ID is already registered" CronJobQueueName = "workflow_cron_queue" ) - -func RegisterCronJobs(config *config.Config) error { - var err error - if wfClient == nil { - wfClient, err = client.Dial(client.Options{ - HostPort: config.WorkFLow.Endpoint, - }) - if err != nil { - return fmt.Errorf("unable to create workflow client, error:%w", err) - } - } - - if !config.Saas { - _, err = wfClient.ScheduleClient().Create(context.Background(), client.ScheduleOptions{ - ID: "sync-as-client-schedule", - Spec: client.ScheduleSpec{ - CronExpressions: []string{config.CronJob.SyncAsClientCronExpression}, - }, - Overlap: enumspb.SCHEDULE_OVERLAP_POLICY_SKIP, - Action: &client.ScheduleWorkflowAction{ - ID: "sync-as-client-workflow", - TaskQueue: CronJobQueueName, - Workflow: SyncAsClientWorkflow, - Args: []interface{}{config}, - }, - }) - if err != nil && err.Error() != AlreadyScheduledMessage { - return fmt.Errorf("unable to create schedule, error:%w", err) - } - } - - _, err = wfClient.ScheduleClient().Create(context.Background(), client.ScheduleOptions{ - ID: "calc-recom-score-schedule", - Spec: client.ScheduleSpec{ - CronExpressions: []string{config.CronJob.CalcRecomScoreCronExpression}, - }, - Overlap: enumspb.SCHEDULE_OVERLAP_POLICY_SKIP, - Action: &client.ScheduleWorkflowAction{ - ID: "calc-recom-score-workflow", - TaskQueue: CronJobQueueName, - Workflow: CalcRecomScoreWorkflow, - Args: []interface{}{config}, - }, - }) - if err != nil && err.Error() != AlreadyScheduledMessage { - return fmt.Errorf("unable to create schedule, error:%w", err) - } - - return nil -} - -func StartCronWorker(config *config.Config) error { - var err error - if wfClient == nil { - wfClient, err = client.Dial(client.Options{ - HostPort: config.WorkFLow.Endpoint, - }) - if err != nil { - return fmt.Errorf("unable to create workflow client, error:%w", err) - } - } - wfWorker = worker.New(wfClient, CronJobQueueName, worker.Options{}) - if !config.Saas { - wfWorker.RegisterWorkflow(SyncAsClientWorkflow) - wfWorker.RegisterActivity(activity.SyncAsClient) - } - wfWorker.RegisterWorkflow(CalcRecomScoreWorkflow) - wfWorker.RegisterActivity(activity.CalcRecomScore) - - return wfWorker.Start() -} diff --git a/api/workflow/cron_worker_ce.go b/api/workflow/cron_worker_ce.go new file mode 100644 index 00000000..faee075f --- /dev/null +++ b/api/workflow/cron_worker_ce.go @@ -0,0 +1,63 @@ +//go:build !ee && !saas + +package workflow + +import ( + "context" + "fmt" + + enumspb "go.temporal.io/api/enums/v1" + "go.temporal.io/sdk/client" + "go.temporal.io/sdk/worker" + "opencsg.com/csghub-server/builder/temporal" + "opencsg.com/csghub-server/common/config" +) + +func RegisterCronJobs(config *config.Config, temporalClient temporal.Client) error { + var err error + scheduler := temporalClient.ScheduleClient() + + _, err = scheduler.Create(context.Background(), client.ScheduleOptions{ + ID: "sync-as-client-schedule", + Spec: client.ScheduleSpec{ + CronExpressions: []string{config.CronJob.SyncAsClientCronExpression}, + }, + Overlap: enumspb.SCHEDULE_OVERLAP_POLICY_SKIP, + Action: &client.ScheduleWorkflowAction{ + ID: "sync-as-client-workflow", + TaskQueue: CronJobQueueName, + Workflow: SyncAsClientWorkflow, + Args: []interface{}{config}, + }, + }) + if err != nil && err.Error() != AlreadyScheduledMessage { + return fmt.Errorf("unable to create schedule, error:%w", err) + } + + _, err = scheduler.Create(context.Background(), client.ScheduleOptions{ + ID: "calc-recom-score-schedule", + Spec: client.ScheduleSpec{ + CronExpressions: []string{config.CronJob.CalcRecomScoreCronExpression}, + }, + Overlap: enumspb.SCHEDULE_OVERLAP_POLICY_SKIP, + Action: &client.ScheduleWorkflowAction{ + ID: "calc-recom-score-workflow", + TaskQueue: CronJobQueueName, + Workflow: CalcRecomScoreWorkflow, + Args: []interface{}{config}, + }, + }) + if err != nil && err.Error() != AlreadyScheduledMessage { + return fmt.Errorf("unable to create schedule, error:%w", err) + } + + return nil +} + +func RegisterCronWorker(config *config.Config, temporalClient temporal.Client) { + + wfWorker := temporalClient.NewWorker(CronJobQueueName, worker.Options{}) + wfWorker.RegisterWorkflow(SyncAsClientWorkflow) + wfWorker.RegisterWorkflow(CalcRecomScoreWorkflow) + +} diff --git a/api/workflow/handle_push.go b/api/workflow/handle_push.go index 05e9c4d1..f3746025 100644 --- a/api/workflow/handle_push.go +++ b/api/workflow/handle_push.go @@ -6,12 +6,10 @@ import ( "go.temporal.io/sdk/temporal" "go.temporal.io/sdk/workflow" - "opencsg.com/csghub-server/api/workflow/activity" - "opencsg.com/csghub-server/common/config" "opencsg.com/csghub-server/common/types" ) -func HandlePushWorkflow(ctx workflow.Context, req *types.GiteaCallbackPushReq, config *config.Config) error { +func HandlePushWorkflow(ctx workflow.Context, req *types.GiteaCallbackPushReq) error { logger := workflow.GetLogger(ctx) logger.Info("handle push workflow started") @@ -26,35 +24,35 @@ func HandlePushWorkflow(ctx workflow.Context, req *types.GiteaCallbackPushReq, c ctx = workflow.WithActivityOptions(ctx, options) // Watch space change - err := workflow.ExecuteActivity(ctx, activity.WatchSpaceChange, req, config).Get(ctx, nil) + err := workflow.ExecuteActivity(ctx, activities.WatchSpaceChange, req).Get(ctx, nil) if err != nil { logger.Error("failed to watch space change", "error", err, "req", req) return err } // Watch repo relation - err = workflow.ExecuteActivity(ctx, activity.WatchRepoRelation, req, config).Get(ctx, nil) + err = workflow.ExecuteActivity(ctx, activities.WatchRepoRelation, req).Get(ctx, nil) if err != nil { logger.Error("failed to watch repo relation", "error", err, "req", req) return err } // Set repo update time - err = workflow.ExecuteActivity(ctx, activity.SetRepoUpdateTime, req, config).Get(ctx, nil) + err = workflow.ExecuteActivity(ctx, activities.SetRepoUpdateTime, req).Get(ctx, nil) if err != nil { logger.Error("failed to set repo update time", "error", err, "req", req) return err } // Update repo infos - err = workflow.ExecuteActivity(ctx, activity.UpdateRepoInfos, req, config).Get(ctx, nil) + err = workflow.ExecuteActivity(ctx, activities.UpdateRepoInfos, req).Get(ctx, nil) if err != nil { logger.Error("failed to update repo infos", "error", err, "req", req) return err } // Sensitive check - err = workflow.ExecuteActivity(ctx, activity.SensitiveCheck, req, config).Get(ctx, nil) + err = workflow.ExecuteActivity(ctx, activities.SensitiveCheck, req).Get(ctx, nil) if err != nil { logger.Error("failed to sensitive check", "error", err, "req", req) return err diff --git a/api/workflow/worker.go b/api/workflow/worker.go deleted file mode 100644 index bad5bd62..00000000 --- a/api/workflow/worker.go +++ /dev/null @@ -1,49 +0,0 @@ -package workflow - -import ( - "fmt" - - "go.temporal.io/sdk/client" - "go.temporal.io/sdk/worker" - "opencsg.com/csghub-server/api/workflow/activity" - "opencsg.com/csghub-server/common/config" -) - -const HandlePushQueueName = "workflow_handle_push_queue" - -var ( - wfWorker worker.Worker - wfClient client.Client -) - -func StartWorker(config *config.Config) error { - var err error - wfClient, err = client.Dial(client.Options{ - HostPort: config.WorkFLow.Endpoint, - }) - if err != nil { - return fmt.Errorf("unable to create workflow client, error:%w", err) - } - wfWorker = worker.New(wfClient, HandlePushQueueName, worker.Options{}) - wfWorker.RegisterWorkflow(HandlePushWorkflow) - wfWorker.RegisterActivity(activity.WatchSpaceChange) - wfWorker.RegisterActivity(activity.WatchRepoRelation) - wfWorker.RegisterActivity(activity.SetRepoUpdateTime) - wfWorker.RegisterActivity(activity.UpdateRepoInfos) - wfWorker.RegisterActivity(activity.SensitiveCheck) - - return wfWorker.Start() -} - -func StopWorker() { - if wfWorker != nil { - wfWorker.Stop() - } - if wfClient != nil { - wfClient.Close() - } -} - -func GetWorkflowClient() client.Client { - return wfClient -} diff --git a/api/workflow/worker_ce.go b/api/workflow/worker_ce.go new file mode 100644 index 00000000..0af82e7a --- /dev/null +++ b/api/workflow/worker_ce.go @@ -0,0 +1,80 @@ +//go:build !ee && !saas + +package workflow + +import ( + "fmt" + + "go.temporal.io/sdk/client" + "go.temporal.io/sdk/worker" + "opencsg.com/csghub-server/api/workflow/activity" + "opencsg.com/csghub-server/builder/git" + "opencsg.com/csghub-server/builder/git/gitserver" + "opencsg.com/csghub-server/builder/store/database" + "opencsg.com/csghub-server/builder/temporal" + "opencsg.com/csghub-server/common/config" + "opencsg.com/csghub-server/component" + "opencsg.com/csghub-server/component/callback" +) + +const HandlePushQueueName = "workflow_handle_push_queue" + +var activities activity.Activities + +func StartWorkflow(cfg *config.Config) error { + gitcallback, err := callback.NewGitCallback(cfg) + if err != nil { + return err + } + recom, err := component.NewRecomComponent(cfg) + if err != nil { + return err + } + gitserver, err := git.NewGitServer(cfg) + if err != nil { + return err + } + multisync, err := component.NewMultiSyncComponent(cfg) + if err != nil { + return err + } + temporalClient, err := client.Dial(client.Options{ + HostPort: cfg.WorkFLow.Endpoint, + }) + if err != nil { + return fmt.Errorf("unable to create workflow client, error: %w", err) + } + client, err := temporal.NewClient(temporalClient) + if err != nil { + return err + } + return StartWorkflowDI( + cfg, gitcallback, recom, + gitserver, multisync, database.NewSyncClientSettingStore(), client, + ) +} + +func StartWorkflowDI( + cfg *config.Config, + callback callback.GitCallbackComponent, + recom component.RecomComponent, + gitServer gitserver.GitServer, + multisync component.MultiSyncComponent, + syncClientSetting database.SyncClientSettingStore, + temporalClient temporal.Client, +) error { + worker := temporalClient.NewWorker(HandlePushQueueName, worker.Options{}) + act := activity.NewActivities(cfg, callback, recom, gitServer, multisync, syncClientSetting) + worker.RegisterActivity(act) + + worker.RegisterWorkflow(HandlePushWorkflow) + + RegisterCronWorker(cfg, temporalClient) + + err := temporalClient.Start() + if err != nil { + return fmt.Errorf("failed to start worker: %w", err) + } + return nil + +} diff --git a/api/workflow/workflow_ce_test.go b/api/workflow/workflow_ce_test.go new file mode 100644 index 00000000..1e499d60 --- /dev/null +++ b/api/workflow/workflow_ce_test.go @@ -0,0 +1,54 @@ +//go:build !ee && !saas + +package workflow_test + +import ( + "testing" + + "github.com/stretchr/testify/mock" + "go.temporal.io/sdk/testsuite" + mock_git "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/git/gitserver" + mock_temporal "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/temporal" + mock_component "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/component" + mock_callback "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/component/callback" + "opencsg.com/csghub-server/api/workflow" + "opencsg.com/csghub-server/common/config" + "opencsg.com/csghub-server/common/tests" +) + +func newWorkflowTester(t *testing.T) (*workflowTester, error) { + suite := testsuite.WorkflowTestSuite{} + tester := &workflowTester{env: suite.NewTestWorkflowEnvironment()} + + // Mock the dependencies + tester.mocks.stores = tests.NewMockStores(t) + + mcb := mock_callback.NewMockGitCallbackComponent(t) + tester.mocks.callback = mcb + + mr := mock_component.NewMockRecomComponent(t) + tester.mocks.recom = mr + + mm := mock_component.NewMockMultiSyncComponent(t) + tester.mocks.multisync = mm + + mg := mock_git.NewMockGitServer(t) + tester.mocks.gitServer = mg + + mtc := mock_temporal.NewMockClient(t) + mtc.EXPECT().NewWorker(workflow.HandlePushQueueName, mock.Anything).Return(tester.env) + mtc.EXPECT().NewWorker(workflow.CronJobQueueName, mock.Anything).Return(tester.env) + mtc.EXPECT().Start().Return(nil) + tester.mocks.temporal = mtc + + cfg := &config.Config{} + + err := workflow.StartWorkflowDI( + cfg, mcb, mr, mg, mm, tester.mocks.stores.SyncClientSettingMock(), mtc, + ) + + if err != nil { + return nil, err + } + return tester, nil +} diff --git a/api/workflow/workflow_test.go b/api/workflow/workflow_test.go new file mode 100644 index 00000000..6f29e91e --- /dev/null +++ b/api/workflow/workflow_test.go @@ -0,0 +1,74 @@ +package workflow_test + +import ( + "testing" + + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + "go.temporal.io/sdk/testsuite" + mock_git "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/git/gitserver" + mock_temporal "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/temporal" + mock_component "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/component" + mock_callback "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/component/callback" + "opencsg.com/csghub-server/api/workflow" + "opencsg.com/csghub-server/builder/multisync" + "opencsg.com/csghub-server/builder/store/database" + "opencsg.com/csghub-server/common/tests" + "opencsg.com/csghub-server/common/types" +) + +type workflowTester struct { + env *testsuite.TestWorkflowEnvironment + mocks struct { + callback *mock_callback.MockGitCallbackComponent + recom *mock_component.MockRecomComponent + multisync *mock_component.MockMultiSyncComponent + gitServer *mock_git.MockGitServer + temporal *mock_temporal.MockClient + stores *tests.MockStores + } +} + +func TestWorkflow_CalcRecomScoreWorkflow(t *testing.T) { + tester, err := newWorkflowTester(t) + require.NoError(t, err) + + tester.mocks.recom.EXPECT().CalculateRecomScore(mock.Anything).Return() + tester.env.ExecuteWorkflow(workflow.CalcRecomScoreWorkflow) + require.True(t, tester.env.IsWorkflowCompleted()) + require.NoError(t, tester.env.GetWorkflowError()) +} + +func TestWorkflow_SyncAsClient(t *testing.T) { + tester, err := newWorkflowTester(t) + require.NoError(t, err) + + tester.mocks.stores.SyncClientSettingMock().EXPECT().First(mock.Anything).Return( + &database.SyncClientSetting{Token: "tk"}, nil, + ) + tester.mocks.multisync.EXPECT().SyncAsClient( + mock.Anything, multisync.FromOpenCSG("", "tk"), + ).Return(nil) + + tester.env.ExecuteWorkflow(workflow.SyncAsClientWorkflow) + require.True(t, tester.env.IsWorkflowCompleted()) + require.NoError(t, tester.env.GetWorkflowError()) + +} + +func TestWorkflow_HandlePushWorkflow(t *testing.T) { + tester, err := newWorkflowTester(t) + require.NoError(t, err) + + tester.mocks.callback.EXPECT().SetRepoVisibility(true).Return() + tester.mocks.callback.EXPECT().WatchSpaceChange(mock.Anything, &types.GiteaCallbackPushReq{}).Return(nil) + tester.mocks.callback.EXPECT().WatchRepoRelation(mock.Anything, &types.GiteaCallbackPushReq{}).Return(nil) + tester.mocks.callback.EXPECT().SetRepoUpdateTime(mock.Anything, &types.GiteaCallbackPushReq{}).Return(nil) + tester.mocks.callback.EXPECT().UpdateRepoInfos(mock.Anything, &types.GiteaCallbackPushReq{}).Return(nil) + tester.mocks.callback.EXPECT().SensitiveCheck(mock.Anything, &types.GiteaCallbackPushReq{}).Return(nil) + + tester.env.ExecuteWorkflow(workflow.HandlePushWorkflow, &types.GiteaCallbackPushReq{}) + require.True(t, tester.env.IsWorkflowCompleted()) + require.NoError(t, tester.env.GetWorkflowError()) + +} diff --git a/builder/temporal/temporal.go b/builder/temporal/temporal.go new file mode 100644 index 00000000..43439db9 --- /dev/null +++ b/builder/temporal/temporal.go @@ -0,0 +1,61 @@ +package temporal + +import ( + "go.temporal.io/sdk/client" + "go.temporal.io/sdk/worker" +) + +type Client interface { + client.Client + NewWorker(queue string, options worker.Options) worker.Registry + Start() error + Stop() +} + +type clientImpl struct { + client.Client + workers []worker.Worker +} + +var _client Client = &clientImpl{} + +func NewClient(temporalClient client.Client) (*clientImpl, error) { + c := _client.(*clientImpl) + c.Client = temporalClient + + return c, nil +} + +func (c *clientImpl) NewWorker(queue string, options worker.Options) worker.Registry { + w := worker.New(c.Client, queue, options) + c.workers = append(c.workers, w) + return w +} + +func (c *clientImpl) Start() error { + for _, worker := range c.workers { + err := worker.Start() + if err != nil { + return err + } + } + return nil +} + +func (c *clientImpl) Stop() { + for _, worker := range c.workers { + worker.Stop() + } + + if c.Client != nil { + c.Close() + } +} + +func GetClient() Client { + return _client +} + +func Stop() { + _client.Close() +} diff --git a/builder/temporal/temporal_test.go b/builder/temporal/temporal_test.go new file mode 100644 index 00000000..0d3defcf --- /dev/null +++ b/builder/temporal/temporal_test.go @@ -0,0 +1,71 @@ +package temporal_test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/require" + "go.temporal.io/sdk/client" + "go.temporal.io/sdk/worker" + "go.temporal.io/sdk/workflow" + "go.temporal.io/server/temporaltest" + "opencsg.com/csghub-server/builder/temporal" +) + +type Tester struct { + client temporal.Client + counter int + total int +} + +func (t *Tester) Count(ctx workflow.Context) error { + t.counter += 1 + return nil +} + +func (t *Tester) Add(ctx workflow.Context) error { + t.total += 1 + return nil +} + +func TestTemporalClient(t *testing.T) { + ts := temporaltest.NewServer(temporaltest.WithT(t)) + defer ts.Stop() + c := ts.GetDefaultClient() + + tester := &Tester{client: temporal.GetClient()} + _, err := temporal.NewClient(c) + require.NoError(t, err) + + worker1 := tester.client.NewWorker("q1", worker.Options{}) + worker1.RegisterWorkflow(tester.Count) + worker2 := tester.client.NewWorker("q2", worker.Options{}) + worker2.RegisterWorkflow(tester.Add) + + err = tester.client.Start() + require.NoError(t, err) + + r, err := tester.client.ExecuteWorkflow(context.TODO(), client.StartWorkflowOptions{ + TaskQueue: "q1", + }, tester.Count) + require.NoError(t, err) + err = r.Get(context.Background(), nil) + require.NoError(t, err) + + r, err = tester.client.ExecuteWorkflow(context.TODO(), client.StartWorkflowOptions{ + TaskQueue: "q2", + }, tester.Add) + require.NoError(t, err) + err = r.Get(context.Background(), nil) + require.NoError(t, err) + + require.Equal(t, 1, tester.counter) + require.Equal(t, 1, tester.total) + + temporal.Stop() + _, err = tester.client.ExecuteWorkflow(context.TODO(), client.StartWorkflowOptions{ + TaskQueue: "q1", + }, tester.Count) + require.Error(t, err) + +} diff --git a/cmd/csghub-server/cmd/mirror/repo_sync.go b/cmd/csghub-server/cmd/mirror/repo_sync.go index 25699681..cabfc1a8 100644 --- a/cmd/csghub-server/cmd/mirror/repo_sync.go +++ b/cmd/csghub-server/cmd/mirror/repo_sync.go @@ -1,11 +1,10 @@ package mirror import ( - "fmt" - "github.com/spf13/cobra" "opencsg.com/csghub-server/api/workflow" "opencsg.com/csghub-server/builder/store/database" + "opencsg.com/csghub-server/builder/temporal" "opencsg.com/csghub-server/common/config" "opencsg.com/csghub-server/mirror" ) @@ -30,13 +29,14 @@ var repoSyncCmd = &cobra.Command{ if err != nil { return err } - err = workflow.StartWorker(cfg) + + err = workflow.StartWorkflow(cfg) if err != nil { - return fmt.Errorf("failed to start worker: %w", err) + return err } repoSYncer.Run() - workflow.StopWorker() + temporal.Stop() return nil }, diff --git a/cmd/csghub-server/cmd/start/server.go b/cmd/csghub-server/cmd/start/server.go index c9e66bb6..c1bac060 100644 --- a/cmd/csghub-server/cmd/start/server.go +++ b/cmd/csghub-server/cmd/start/server.go @@ -13,6 +13,7 @@ import ( "opencsg.com/csghub-server/builder/deploy/common" "opencsg.com/csghub-server/builder/event" "opencsg.com/csghub-server/builder/store/database" + "opencsg.com/csghub-server/builder/temporal" "opencsg.com/csghub-server/common/config" "opencsg.com/csghub-server/common/types" "opencsg.com/csghub-server/docs" @@ -83,25 +84,16 @@ var serverCmd = &cobra.Command{ if err != nil { return fmt.Errorf("failed to init deploy: %w", err) } - err = workflow.StartWorker(cfg) + + err = workflow.StartWorkflow(cfg) if err != nil { - return fmt.Errorf("failed to start worker: %w", err) + return err } r, err := router.NewRouter(cfg, enableSwagger) if err != nil { return fmt.Errorf("failed to init router: %w", err) } - err = workflow.RegisterCronJobs(cfg) - if err != nil { - return fmt.Errorf("failed to register cron jobs: %w", err) - } - - err = workflow.StartCronWorker(cfg) - if err != nil { - return fmt.Errorf("failed to start cron worker: %w", err) - } - server := httpbase.NewGracefulServer( httpbase.GraceServerOpt{ Port: cfg.APIServer.Port, @@ -120,7 +112,7 @@ var serverCmd = &cobra.Command{ } server.Run() - workflow.StopWorker() + temporal.Stop() return nil }, diff --git a/cmd/csghub-server/cmd/trigger/git_callback.go b/cmd/csghub-server/cmd/trigger/git_callback.go index 24fb4509..f108511a 100644 --- a/cmd/csghub-server/cmd/trigger/git_callback.go +++ b/cmd/csghub-server/cmd/trigger/git_callback.go @@ -11,6 +11,7 @@ import ( "opencsg.com/csghub-server/api/workflow" "opencsg.com/csghub-server/builder/git/gitserver" "opencsg.com/csghub-server/builder/store/database" + "opencsg.com/csghub-server/builder/temporal" "opencsg.com/csghub-server/common/config" "opencsg.com/csghub-server/common/types" ) @@ -39,11 +40,12 @@ var gitCallbackCmd = &cobra.Command{ if err != nil { return fmt.Errorf("failed to load config: %w", err) } - err = workflow.StartWorker(config) + + err = workflow.StartWorkflow(config) if err != nil { - slog.Error("failed to start worker", slog.Any("error", err)) - return fmt.Errorf("failed to start worker: %w", err) + return err } + if len(repoPaths) > 0 { for _, rp := range repoPaths { parts := strings.Split(rp, "/") @@ -85,14 +87,13 @@ var gitCallbackCmd = &cobra.Command{ req.Commits = append(req.Commits, types.GiteaCallbackPushReq_Commit{}) req.Commits[0].Added = append(req.Commits[0].Added, filePaths...) //start workflow to handle push request - workflowClient := workflow.GetWorkflowClient() + workflowClient := temporal.GetClient() workflowOptions := client.StartWorkflowOptions{ TaskQueue: workflow.HandlePushQueueName, } - we, err := workflowClient.ExecuteWorkflow(context.Background(), workflowOptions, workflow.HandlePushWorkflow, - req, - config, + we, err := workflowClient.ExecuteWorkflow( + context.Background(), workflowOptions, workflow.HandlePushWorkflow, req, ) if err != nil { slog.Error("failed to handle git push callback", slog.String("repo", repo.Path), slog.Any("error", err)) diff --git a/component/callback/git_callback.go b/component/callback/git_callback.go index 0810f1e4..e022ff33 100644 --- a/component/callback/git_callback.go +++ b/component/callback/git_callback.go @@ -27,6 +27,7 @@ type GitCallbackComponent interface { WatchRepoRelation(ctx context.Context, req *types.GiteaCallbackPushReq) error SetRepoUpdateTime(ctx context.Context, req *types.GiteaCallbackPushReq) error UpdateRepoInfos(ctx context.Context, req *types.GiteaCallbackPushReq) error + SensitiveCheck(ctx context.Context, req *types.GiteaCallbackPushReq) error } type gitCallbackComponentImpl struct { diff --git a/go.mod b/go.mod index 93e4fadf..87eab4f6 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,8 @@ module opencsg.com/csghub-server -go 1.23 +go 1.23.2 + +toolchain go1.23.4 require ( github.com/DATA-DOG/go-txdb v0.2.0 @@ -26,7 +28,7 @@ require ( github.com/sethvargo/go-envconfig v1.1.0 github.com/spf13/cast v1.5.1 github.com/spf13/cobra v1.8.0 - github.com/stretchr/testify v1.9.0 + github.com/stretchr/testify v1.10.0 github.com/swaggo/files v1.0.1 github.com/swaggo/gin-swagger v1.6.0 github.com/swaggo/swag v1.16.2 @@ -39,9 +41,10 @@ require ( github.com/uptrace/bun/driver/sqliteshim v1.1.16 github.com/uptrace/bun/extra/bundebug v1.1.16 gitlab.com/gitlab-org/gitaly/v16 v16.11.8 - go.temporal.io/api v1.40.0 - go.temporal.io/sdk v1.30.0 - google.golang.org/grpc v1.66.0 + go.temporal.io/api v1.43.0 + go.temporal.io/sdk v1.31.0 + go.temporal.io/server v1.26.2 + google.golang.org/grpc v1.67.1 gopkg.in/yaml.v2 v2.4.0 gopkg.in/yaml.v3 v3.0.1 k8s.io/api v0.31.3 @@ -51,20 +54,31 @@ require ( ) require ( - cloud.google.com/go/compute/metadata v0.3.0 // indirect - cloud.google.com/go/monitoring v1.18.0 // indirect - cloud.google.com/go/trace v1.10.5 // indirect + cloud.google.com/go v0.114.0 // indirect + cloud.google.com/go/auth v0.5.0 // indirect + cloud.google.com/go/auth/oauth2adapt v0.2.2 // indirect + cloud.google.com/go/compute/metadata v0.5.0 // indirect + cloud.google.com/go/iam v1.1.8 // indirect + cloud.google.com/go/monitoring v1.19.0 // indirect + cloud.google.com/go/storage v1.41.0 // indirect + cloud.google.com/go/trace v1.10.7 // indirect contrib.go.opencensus.io/exporter/stackdriver v0.13.14 // indirect dario.cat/mergo v1.0.0 // indirect + filippo.io/edwards25519 v1.1.0 // indirect github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect github.com/DataDog/datadog-go v4.4.0+incompatible // indirect github.com/DataDog/sketches-go v1.0.0 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect - github.com/aws/aws-sdk-go v1.50.36 // indirect + github.com/apache/thrift v0.16.0 // indirect + github.com/aws/aws-sdk-go v1.53.15 // indirect github.com/beevik/ntp v1.3.1 // indirect + github.com/benbjohnson/clock v1.1.0 // indirect github.com/beorn7/perks v1.0.1 // indirect + github.com/blang/semver/v4 v4.0.0 // indirect github.com/bytedance/sonic/loader v0.1.1 // indirect - github.com/cenkalti/backoff/v4 v4.2.1 // indirect + github.com/cactus/go-statsd-client/statsd v0.0.0-20200423205355-cb0885a1018c // indirect + github.com/cactus/go-statsd-client/v5 v5.1.0 // indirect + github.com/cenkalti/backoff/v4 v4.3.0 // indirect github.com/census-instrumentation/opencensus-proto v0.4.1 // indirect github.com/cloudwego/base64x v0.1.4 // indirect github.com/cloudwego/iasm v0.2.0 // indirect @@ -72,27 +86,41 @@ require ( github.com/containerd/log v0.1.0 // indirect github.com/containerd/platforms v0.2.1 // indirect github.com/cpuguy83/dockercfg v0.3.2 // indirect + github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da // indirect github.com/distribution/reference v0.6.0 // indirect github.com/docker/docker v27.1.1+incompatible // indirect github.com/docker/go-connections v0.5.0 // indirect github.com/docker/go-units v0.5.0 // indirect + github.com/emirpasic/gods v1.18.1 // indirect github.com/evanphx/json-patch v5.9.0+incompatible // indirect github.com/facebookgo/clock v0.0.0-20150410010913-600d898af40a // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/fxamacker/cbor/v2 v2.7.0 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-ole/go-ole v1.2.6 // indirect + github.com/go-sql-driver/mysql v1.8.1 // indirect + github.com/gocql/gocql v1.6.0 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/mock v1.6.0 // indirect + github.com/golang/snappy v0.0.4 // indirect github.com/google/s2a-go v0.1.7 // indirect github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect - github.com/googleapis/gax-go/v2 v2.12.2 // indirect + github.com/googleapis/gax-go/v2 v2.12.4 // indirect + github.com/gorilla/mux v1.8.1 // indirect github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 // indirect github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.0.0 // indirect github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 // indirect + github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect github.com/hashicorp/yamux v0.1.2-0.20220728231024-8f49b6f63f18 // indirect + github.com/iancoleman/strcase v0.3.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect + github.com/jackc/pgx/v5 v5.6.0 // indirect + github.com/jackc/puddle/v2 v2.2.1 // indirect + github.com/jmoiron/sqlx v1.3.4 // indirect + github.com/lib/pq v1.10.9 // indirect github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20210210170715-a8dfcb80d3a7 // indirect github.com/lightstep/lightstep-tracer-go v0.25.0 // indirect github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect @@ -107,26 +135,36 @@ require ( github.com/nats-io/nkeys v0.4.7 // indirect github.com/nats-io/nuid v1.0.1 // indirect github.com/ncruces/go-strftime v0.1.9 // indirect - github.com/nexus-rpc/sdk-go v0.0.11 // indirect + github.com/nexus-rpc/sdk-go v0.1.0 // indirect github.com/oklog/ulid/v2 v2.0.2 // indirect + github.com/olivere/elastic/v7 v7.0.32 // indirect github.com/opencontainers/image-spec v1.1.0 // indirect github.com/pborman/uuid v1.2.1 // indirect github.com/philhofer/fwd v1.1.1 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect - github.com/prometheus/client_golang v1.19.0 // indirect - github.com/prometheus/client_model v0.6.0 // indirect - github.com/prometheus/common v0.48.0 // indirect - github.com/prometheus/procfs v0.12.0 // indirect + github.com/prometheus/client_golang v1.20.4 // indirect + github.com/prometheus/client_model v0.6.1 // indirect + github.com/prometheus/common v0.60.0 // indirect + github.com/prometheus/procfs v0.15.1 // indirect github.com/prometheus/prometheus v0.50.1 // indirect + github.com/rcrowley/go-metrics v0.0.0-20141108142129-dee209f2455f // indirect github.com/robfig/cron v1.2.0 // indirect + github.com/robfig/cron/v3 v3.0.1 // indirect github.com/sebest/xff v0.0.0-20210106013422-671bd2870b3a // indirect github.com/shirou/gopsutil/v3 v3.23.12 // indirect github.com/shoenig/go-m1cpu v0.1.6 // indirect + github.com/sony/gobreaker v1.0.0 // indirect github.com/stretchr/objx v0.5.2 // indirect + github.com/temporalio/ringpop-go v0.0.0-20241119001152-e505ebd8f887 // indirect + github.com/temporalio/sqlparser v0.0.0-20231115171017-f4060bcfa6cb // indirect + github.com/temporalio/tchannel-go v1.22.1-0.20240528171429-1db37fdea938 // indirect github.com/tinylib/msgp v1.1.2 // indirect github.com/tklauser/go-sysconf v0.3.12 // indirect github.com/tklauser/numcpus v0.6.1 // indirect + github.com/twmb/murmur3 v1.1.8 // indirect + github.com/uber-common/bark v1.0.0 // indirect + github.com/uber-go/tally/v4 v4.1.17-0.20240412215630-22fe011f5ff0 // indirect github.com/uber/jaeger-client-go v2.30.0+incompatible // indirect github.com/uber/jaeger-lib v2.4.1+incompatible // indirect github.com/x448/float16 v0.8.4 // indirect @@ -134,20 +172,33 @@ require ( gitlab.com/gitlab-org/go/reopen v1.0.0 // indirect gitlab.com/gitlab-org/labkit v1.21.2 // indirect go.opencensus.io v0.24.0 // indirect - go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 // indirect - go.opentelemetry.io/otel v1.24.0 // indirect - go.opentelemetry.io/otel/metric v1.24.0 // indirect - go.opentelemetry.io/otel/trace v1.24.0 // indirect - golang.org/x/exp v0.0.0-20240119083558-1b970713d09a // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.56.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.52.0 // indirect + go.opentelemetry.io/otel v1.31.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.31.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.31.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.31.0 // indirect + go.opentelemetry.io/otel/exporters/prometheus v0.53.0 // indirect + go.opentelemetry.io/otel/metric v1.31.0 // indirect + go.opentelemetry.io/otel/sdk v1.31.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.31.0 // indirect + go.opentelemetry.io/otel/trace v1.31.0 // indirect + go.opentelemetry.io/proto/otlp v1.3.1 // indirect + go.temporal.io/version v0.3.0 // indirect + go.uber.org/dig v1.17.1 // indirect + go.uber.org/fx v1.22.0 // indirect + go.uber.org/mock v0.4.0 // indirect + golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc // indirect golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/api v0.169.0 // indirect - google.golang.org/genproto v0.0.0-20240311173647-c811ad7063a7 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20240827150818-7e3bb234dfed // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20240827150818-7e3bb234dfed // indirect + google.golang.org/api v0.182.0 // indirect + google.golang.org/genproto v0.0.0-20240528184218-531527333157 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20241007155032-5fefd90f89a9 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 // indirect gopkg.in/DataDog/dd-trace-go.v1 v1.32.0 // indirect gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect - modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 // indirect + gopkg.in/go-jose/go-jose.v2 v2.6.3 // indirect + gopkg.in/validator.v2 v2.0.1 // indirect + modernc.org/gc/v3 v3.0.0-20240304020402-f0dba7c97c2b // indirect ) require ( @@ -172,7 +223,7 @@ require ( github.com/dustin/go-humanize v1.0.1 // indirect github.com/emicklei/go-restful/v3 v3.11.0 // indirect github.com/evanphx/json-patch/v5 v5.8.0 // indirect - github.com/fatih/color v1.15.0 // indirect + github.com/fatih/color v1.17.0 // indirect github.com/gabriel-vasile/mimetype v1.4.3 // indirect github.com/gin-contrib/sse v0.1.0 // indirect github.com/go-fed/httpsig v1.1.0 // indirect @@ -205,7 +256,7 @@ require ( github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/josharian/intern v1.0.0 // indirect github.com/json-iterator/go v1.1.12 // indirect - github.com/klauspost/compress v1.17.4 // indirect + github.com/klauspost/compress v1.17.9 // indirect github.com/klauspost/cpuid/v2 v2.2.7 // indirect github.com/leodido/go-urn v1.4.0 // indirect github.com/mailru/easyjson v0.7.7 // indirect @@ -234,11 +285,11 @@ require ( github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect go.uber.org/atomic v1.11.0 // indirect go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.26.0 // indirect + go.uber.org/zap v1.27.0 // indirect golang.org/x/arch v0.8.0 // indirect golang.org/x/crypto v0.31.0 - golang.org/x/net v0.28.0 // indirect - golang.org/x/oauth2 v0.22.0 // indirect + golang.org/x/net v0.31.0 // indirect + golang.org/x/oauth2 v0.23.0 // indirect golang.org/x/sync v0.10.0 // indirect golang.org/x/sys v0.28.0 // indirect golang.org/x/term v0.27.0 // indirect @@ -246,7 +297,7 @@ require ( golang.org/x/time v0.5.0 // indirect golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect - google.golang.org/protobuf v1.34.2 + google.golang.org/protobuf v1.35.1 gopkg.in/inf.v0 v0.9.1 // indirect gopkg.in/ini.v1 v1.67.0 // indirect k8s.io/klog/v2 v2.130.1 // indirect @@ -255,10 +306,10 @@ require ( knative.dev/networking v0.0.0-20240116081125-ce0738abf051 // indirect knative.dev/pkg v0.0.0-20240116073220-b488e7be5902 // indirect mellium.im/sasl v0.3.1 // indirect - modernc.org/libc v1.41.0 // indirect + modernc.org/libc v1.55.3 // indirect modernc.org/mathutil v1.6.0 // indirect - modernc.org/memory v1.7.2 // indirect - modernc.org/sqlite v1.29.1 // indirect + modernc.org/memory v1.8.0 // indirect + modernc.org/sqlite v1.34.1 // indirect modernc.org/strutil v1.2.0 // indirect modernc.org/token v1.1.0 // indirect sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect diff --git a/go.sum b/go.sum index 52183d31..53f12bcd 100644 --- a/go.sum +++ b/go.sum @@ -1,12 +1,22 @@ cloud.google.com/go v0.16.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -cloud.google.com/go/compute/metadata v0.3.0 h1:Tz+eQXMEqDIKRsmY3cHTL6FVaynIjX2QxYC4trgAKZc= -cloud.google.com/go/compute/metadata v0.3.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= -cloud.google.com/go/monitoring v1.18.0 h1:NfkDLQDG2UR3WYZVQE8kwSbUIEyIqJUPl+aOQdFH1T4= -cloud.google.com/go/monitoring v1.18.0/go.mod h1:c92vVBCeq/OB4Ioyo+NbN2U7tlg5ZH41PZcdvfc+Lcg= -cloud.google.com/go/trace v1.10.5 h1:0pr4lIKJ5XZFYD9GtxXEWr0KkVeigc3wlGpZco0X1oA= -cloud.google.com/go/trace v1.10.5/go.mod h1:9hjCV1nGBCtXbAE4YK7OqJ8pmPYSxPA0I67JwRd5s3M= +cloud.google.com/go v0.114.0 h1:OIPFAdfrFDFO2ve2U7r/H5SwSbBzEdrBdE7xkgwc+kY= +cloud.google.com/go v0.114.0/go.mod h1:ZV9La5YYxctro1HTPug5lXH/GefROyW8PPD4T8n9J8E= +cloud.google.com/go/auth v0.5.0 h1:GtSZfKJkPrZi/s3AkiHnUYVI4dTP/kg8+I3unm0omag= +cloud.google.com/go/auth v0.5.0/go.mod h1:Kqvlz1cf1sNA0D+sYJnkPQOP+JMHkuHeIgVmCRtZOLc= +cloud.google.com/go/auth/oauth2adapt v0.2.2 h1:+TTV8aXpjeChS9M+aTtN/TjdQnzJvmzKFt//oWu7HX4= +cloud.google.com/go/auth/oauth2adapt v0.2.2/go.mod h1:wcYjgpZI9+Yu7LyYBg4pqSiaRkfEK3GQcpb7C/uyF1Q= +cloud.google.com/go/compute/metadata v0.5.0 h1:Zr0eK8JbFv6+Wi4ilXAR8FJ3wyNdpxHKJNPos6LTZOY= +cloud.google.com/go/compute/metadata v0.5.0/go.mod h1:aHnloV2TPI38yx4s9+wAZhHykWvVCfu7hQbF+9CWoiY= +cloud.google.com/go/iam v1.1.8 h1:r7umDwhj+BQyz0ScZMp4QrGXjSTI3ZINnpgU2nlB/K0= +cloud.google.com/go/iam v1.1.8/go.mod h1:GvE6lyMmfxXauzNq8NbgJbeVQNspG+tcdL/W8QO1+zE= +cloud.google.com/go/monitoring v1.19.0 h1:NCXf8hfQi+Kmr56QJezXRZ6GPb80ZI7El1XztyUuLQI= +cloud.google.com/go/monitoring v1.19.0/go.mod h1:25IeMR5cQ5BoZ8j1eogHE5VPJLlReQ7zFp5OiLgiGZw= +cloud.google.com/go/storage v1.41.0 h1:RusiwatSu6lHeEXe3kglxakAmAbfV+rhtPqA6i8RBx0= +cloud.google.com/go/storage v1.41.0/go.mod h1:J1WCa/Z2FcgdEDuPUY8DxT5I+d9mFKsCepp5vR6Sq80= +cloud.google.com/go/trace v1.10.7 h1:gK8z2BIJQ3KIYGddw9RJLne5Fx0FEXkrEQzPaeEYVvk= +cloud.google.com/go/trace v1.10.7/go.mod h1:qk3eiKmZX0ar2dzIJN/3QhY2PIFh1eqcIdaN5uEjQPM= contrib.go.opencensus.io/exporter/ocagent v0.7.1-0.20200907061046-05415f1de66d h1:LblfooH1lKOpp1hIhukktmSAxFkqMPFk9KR6iZ0MJNI= contrib.go.opencensus.io/exporter/ocagent v0.7.1-0.20200907061046-05415f1de66d/go.mod h1:IshRmMJBhDfFj5Y67nVhMYTTIze91RUeT73ipWKs/GY= contrib.go.opencensus.io/exporter/prometheus v0.4.2 h1:sqfsYl5GIY/L570iT+l93ehxaWJs2/OwXtiWwew3oAg= @@ -75,17 +85,29 @@ github.com/aliyun/credentials-go v1.3.1/go.mod h1:8jKYhQuDawt8x2+fusqa1Y6mPxemTs github.com/aliyun/credentials-go v1.3.2 h1:L4WppI9rctC8PdlMgyTkF8bBsy9pyKQEzBD1bHMRl+g= github.com/aliyun/credentials-go v1.3.2/go.mod h1:tlpz4uys4Rn7Ik4/piGRrTbXy2uLKvePgQJJduE+Y5c= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/apache/thrift v0.16.0 h1:qEy6UW60iVOlUy+b9ZR0d5WzUWYGOo4HfopoyBaNmoY= +github.com/apache/thrift v0.16.0/go.mod h1:PHK3hniurgQaNMZYaCLEqXKsYK8upmhPbmdP2FXSqgU= github.com/argoproj/argo-workflows/v3 v3.5.13 h1:d+t+nTBgfHsTTuw+KL3CmBrjvo9/VlRcMNm+FRf8FBA= github.com/argoproj/argo-workflows/v3 v3.5.13/go.mod h1:DecB01a8UXDCjtIh0udY8XfIMIRrWrlbob7hk/uMmg0= -github.com/aws/aws-sdk-go v1.50.36 h1:PjWXHwZPuTLMR1NIb8nEjLucZBMzmf84TLoLbD8BZqk= -github.com/aws/aws-sdk-go v1.50.36/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/aws/aws-sdk-go v1.53.15 h1:FtZmkg7xM8RfP2oY6p7xdKBYrRgkITk9yve2QV7N938= +github.com/aws/aws-sdk-go v1.53.15/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= github.com/beevik/ntp v1.3.1 h1:Y/srlT8L1yQr58kyPWFPZIxRL8ttx2SRIpVYJqZIlAM= github.com/beevik/ntp v1.3.1/go.mod h1:fT6PylBq86Tsq23ZMEe47b7QQrZfYBFPnpzt0a9kJxw= +github.com/benbjohnson/clock v0.0.0-20160125162948-a620c1cc9866/go.mod h1:UMqtWQTnOe4byzwe7Zhwh8f8s+36uszN51sJrSIZlTE= +github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932 h1:mXoPYz/Ul5HYEDvkta6I8/rnYM5gSdSV2tJ6XbZuEtY= +github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k= +github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= +github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= github.com/blendle/zapdriver v1.3.1 h1:C3dydBOWYRiOk+B8X9IVZ5IOe+7cl+tGOexN4QqHfpE= github.com/blendle/zapdriver v1.3.1/go.mod h1:mdXfREi6u5MArG4j9fewC+FGnXaBR+T4Ox4J2u4eHCc= +github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY= +github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4= +github.com/bmizerany/perks v0.0.0-20141205001514-d9a9656a3a4b h1:AP/Y7sqYicnjGDfD5VcY4CIfh1hRXBUavxrvELjTiOE= +github.com/bmizerany/perks v0.0.0-20141205001514-d9a9656a3a4b/go.mod h1:ac9efd0D1fsDb3EJvhqgXRbFx7bs2wqZ10HQPeU8U/Q= github.com/bradfitz/gomemcache v0.0.0-20170208213004-1952afaa557d/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60= github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= @@ -97,10 +119,15 @@ github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4= github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM= github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU= +github.com/cactus/go-statsd-client/statsd v0.0.0-20200423205355-cb0885a1018c h1:HIGF0r/56+7fuIZw2V4isE22MK6xpxWx7BbV8dJ290w= +github.com/cactus/go-statsd-client/statsd v0.0.0-20200423205355-cb0885a1018c/go.mod h1:l/bIBLeOl9eX+wxJAzxS4TveKRtAqlyDpHjhkfO0MEI= +github.com/cactus/go-statsd-client/v4 v4.0.0/go.mod h1:m73kwJp6TN0Ja9P6ycdZhWM1MlfxY/95WZ//IptPQ+Y= +github.com/cactus/go-statsd-client/v5 v5.1.0 h1:sbbdfIl9PgisjEoXzvXI1lwUKWElngsjJKaZeC021P4= +github.com/cactus/go-statsd-client/v5 v5.1.0/go.mod h1:COEvJ1E+/E2L4q6QE5CkjWPi4eeDw9maJBMIuMPBZbY= github.com/casdoor/casdoor-go-sdk v0.41.0 h1:mqqoc1Jub34/OkAQqjeASRAaiy7x/5ZWtGObI08cfEk= github.com/casdoor/casdoor-go-sdk v0.41.0/go.mod h1:cMnkCQJgMYpgAlgEx8reSt1AVaDIQLcJ1zk5pzBaz+4= -github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= -github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= +github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/census-instrumentation/opencensus-proto v0.4.1 h1:iKLQ0xPNFxR/2hzXZMrBo8f1j86j5WHzznCCQxV/b8g= github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw= @@ -135,6 +162,7 @@ github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46t github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/creack/pty v1.1.21 h1:1/QdRyBaHHJP61QkWMXlOIBfsgdDeeKfK8SYVUWJKf0= github.com/creack/pty v1.1.21/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= +github.com/crossdock/crossdock-go v0.0.0-20160816171116-049aabb0122b/go.mod h1:v9FBN7gdVTpiD/+LZ7Po0UKvROyT87uLVxTHVky/dlQ= github.com/d5/tengo/v2 v2.17.0 h1:BWUN9NoJzw48jZKiYDXDIF3QrIVZRm1uV1gTzeZ2lqM= github.com/d5/tengo/v2 v2.17.0/go.mod h1:XRGjEs5I9jYIKTxly6HCF8oiiilk5E/RYXOZ5b0DZC8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -143,6 +171,9 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davidmz/go-pageant v1.0.2 h1:bPblRCh5jGU+Uptpz6LgMZGD5hJoOt7otgT454WvHn0= github.com/davidmz/go-pageant v1.0.2/go.mod h1:P2EDDnMqIwG5Rrp05dTRITj9z2zpGcD9efWSkTNKLIE= +github.com/dgryski/go-farm v0.0.0-20140601200337-fc41e106ee0e/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= +github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= @@ -157,6 +188,8 @@ github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkp github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g= github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= +github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= @@ -167,11 +200,13 @@ github.com/evanphx/json-patch/v5 v5.8.0 h1:lRj6N9Nci7MvzrXuX6HFzU8XjmhPiXPlsKEy1 github.com/evanphx/json-patch/v5 v5.8.0/go.mod h1:VNkHZ/282BpEyt/tObQO8s5CMPmYYq14uClGH4abBuQ= github.com/facebookgo/clock v0.0.0-20150410010913-600d898af40a h1:yDWHCSQ40h88yih2JAcL6Ls/kVkSE8GFACTGVnMPruw= github.com/facebookgo/clock v0.0.0-20150410010913-600d898af40a/go.mod h1:7Ga40egUymuWXxAe151lTNnCv97MddSOVsjpPPkityA= -github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= -github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4= +github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= +github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= +github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.4.3-0.20170329110642-4da3e2cfbabc/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= @@ -196,6 +231,8 @@ github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm github.com/gin-gonic/gin v1.7.7/go.mod h1:axIBovoeJpVj8S3BwE0uPMTeReE4+AfFtqpqaZ1qq1U= github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU= github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y= +github.com/go-faker/faker/v4 v4.4.1 h1:LY1jDgjVkBZWIhATCt+gkl0x9i/7wC61gZx73GTFb+Q= +github.com/go-faker/faker/v4 v4.4.1/go.mod h1:HRLrjis+tYsbFtIHufEPTAIzcZiRu0rS9EYl2Ccwme4= github.com/go-fed/httpsig v1.1.0 h1:9M+hb0jkEICD8/cAiNqEB66R87tTINszBRTjwjQzWcI= github.com/go-fed/httpsig v1.1.0/go.mod h1:RCMrTZvN1bJYtofsG4rd5NaO5obxQ5xBkdiS7xsT7bM= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= @@ -235,6 +272,7 @@ github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBEx github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= +github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= github.com/go-stack/stack v1.6.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= @@ -245,6 +283,8 @@ github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1v github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA= github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= +github.com/gocql/gocql v1.6.0 h1:IdFdOTbnpbd0pDhl4REKQDM+Q0SzKXQ1Yh+YZZ8T/qU= +github.com/gocql/gocql v1.6.0/go.mod h1:3gM2c4D3AnkISwBxGnMMsS8Oy4y2lhbPRsH4xnJrHG8= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/goji/httpauth v0.0.0-20160601135302-2da839ab0f4d/go.mod h1:nnjvkQ9ptGaCkuDUx6wNykzzlUixGxvkme+H/lnzb+A= @@ -262,6 +302,7 @@ github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/lint v0.0.0-20170918230701-e5d664eb928e/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= @@ -281,6 +322,9 @@ github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiu github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/golang/snappy v0.0.0-20170215233205-553a64147049/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/gnostic-models v0.6.8 h1:yo/ABAfM5IMRsS1VnXjTBvUb61tFIHozhlYvRgGre9I= github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYuF5OpfBSENuI8U= github.com/google/go-cmp v0.1.1-0.20171103154506-982329095285/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= @@ -301,6 +345,8 @@ github.com/google/go-containerregistry v0.16.1/go.mod h1:u0qB2l7mvtWVR5kNcbFIhFY github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian/v3 v3.3.3 h1:DIhPTQrbPkgs2yJYdXU/eNACCG5DVQjySNRNlflZ9Fc= +github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0= github.com/google/pprof v0.0.0-20210125172800-10e9aeb4a998/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20240525223248-4bfdf5a9a2af h1:kmjWCqn2qkEml422C2Rrd27c3VGxi6a/6HNq8QmHRKM= @@ -317,12 +363,14 @@ github.com/google/wire v0.6.0/go.mod h1:F4QhpQ9EDIdJ1Mbop/NZBRB+5yrR6qg3BnctaoUk github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs= github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0= github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY= -github.com/googleapis/gax-go/v2 v2.12.2 h1:mhN09QQW1jEWeMF74zGR81R30z4VJzjZsfkUhuHF+DA= -github.com/googleapis/gax-go/v2 v2.12.2/go.mod h1:61M8vcyyXR2kqKFxKrfA22jaA8JGF7Dc8App1U3H6jc= +github.com/googleapis/gax-go/v2 v2.12.4 h1:9gWcmF85Wvq4ryPFvGFaOgPIs1AQX0d0bcbGw4Z96qg= +github.com/googleapis/gax-go/v2 v2.12.4/go.mod h1:KYEYLorsnIGDi/rPC8b5TdlB9kbKoFubselGIoBMCwI= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gorilla/context v1.1.1 h1:AWwleXJkX/nhcU9bZSnZoi3h/qGYqQAGhq6zZe/aQW8= github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= +github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= +github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/securecookie v1.1.1 h1:miw7JPhV+b/lAHSXz4qd/nN9jRiAFV5FwjeKyCS8BvQ= github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4= github.com/gorilla/sessions v1.2.1 h1:DHd3rPN5lE3Ts3D8rKkQ8x/0kqfeNmBAaiSi+o7FsgI= @@ -336,6 +384,8 @@ github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= +github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8= +github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4= github.com/hashicorp/go-version v1.5.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= @@ -345,6 +395,8 @@ github.com/hashicorp/hcl v0.0.0-20170914154624-68e816d1c783/go.mod h1:oZtUIOe8dh github.com/hashicorp/yamux v0.1.2-0.20220728231024-8f49b6f63f18 h1:IVujPV6DRIu1fYF4zUHrfhkngJzmYjelXa+iSUiFZSI= github.com/hashicorp/yamux v0.1.2-0.20220728231024-8f49b6f63f18/go.mod h1:CtWFDAQgb7dxtzFs4tWbplKIe2jSi3+5vKbgIO0SLnQ= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI= +github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4= github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY= @@ -355,12 +407,14 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk= github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= -github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw= -github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A= +github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY= +github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw= github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= github.com/jellydator/ttlcache/v2 v2.11.1 h1:AZGME43Eh2Vv3giG6GeqeLeFXxwxn1/qHItqWZl6U64= github.com/jellydator/ttlcache/v2 v2.11.1/go.mod h1:RtE5Snf0/57e+2cLWFYWCCsLas2Hy3c5Z4n14XmSvTI= +github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4= github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= @@ -368,6 +422,8 @@ github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9Y github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/jmoiron/sqlx v1.3.4 h1:wv+0IJZfL5z0uZoUjlpKgHkgaFSYD+r9CfrXjEXsO7w= +github.com/jmoiron/sqlx v1.3.4/go.mod h1:2BljVx/86SuTyjE+aPYlHCTNvZrnJXghYGpNiXLBMCQ= github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= @@ -379,8 +435,8 @@ github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfV github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4= -github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= +github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= @@ -400,6 +456,7 @@ github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+ github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= +github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20210210170715-a8dfcb80d3a7 h1:YjW+hUb8Fh2S58z4av4t/0cBMK/Q0aP48RocCFsC8yI= @@ -423,6 +480,7 @@ github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Ky github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U= github.com/mattn/go-sqlite3 v2.0.3+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/miekg/dns v1.1.58 h1:ca2Hdkz+cDg/7eNF6V56jjzuZ4aCAE+DbVkILdQWG/4= @@ -469,14 +527,16 @@ github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= -github.com/nexus-rpc/sdk-go v0.0.11 h1:qH3Us3spfp50t5ca775V1va2eE6z1zMQDZY4mvbw0CI= -github.com/nexus-rpc/sdk-go v0.0.11/go.mod h1:TpfkM2Cw0Rlk9drGkoiSMpFqflKTiQLWUNyKJjF8mKQ= +github.com/nexus-rpc/sdk-go v0.1.0 h1:PUL/0vEY1//WnqyEHT5ao4LBRQ6MeNUihmnNGn0xMWY= +github.com/nexus-rpc/sdk-go v0.1.0/go.mod h1:TpfkM2Cw0Rlk9drGkoiSMpFqflKTiQLWUNyKJjF8mKQ= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= github.com/oklog/ulid/v2 v2.0.2 h1:r4fFzBm+bv0wNKNh5eXTwU7i85y5x+uwkxCUTNVQqLc= github.com/oklog/ulid/v2 v2.0.2/go.mod h1:mtBL0Qe/0HAx6/a4Z30qxVIAL1eQDweXq5lxOEiwQ68= +github.com/olivere/elastic/v7 v7.0.32 h1:R7CXvbu8Eq+WlsLgxmKVKPox0oOwAE/2T9Si5BnvK6E= +github.com/olivere/elastic/v7 v7.0.32/go.mod h1:c7PVmLe3Fxq77PIfY/bZmxY/TAamBhCzZ8xDOE09a9k= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= @@ -517,31 +577,38 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw= github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= -github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU= -github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k= +github.com/prashantv/protectmem v0.0.0-20171002184600-e20412882b3a h1:AA9vgIBDjMHPC2McaGPojgV2dcI78ZC0TLNhYCXEKH8= +github.com/prashantv/protectmem v0.0.0-20171002184600-e20412882b3a/go.mod h1:lzZQ3Noex5pfAy7mkAeCjcBDteYU85uWWnJ/y6gKU8k= +github.com/prometheus/client_golang v1.20.4 h1:Tgh3Yr67PaOv/uTqloMsCEdeuFTatm5zIq5+qNN23vI= +github.com/prometheus/client_golang v1.20.4/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.6.0 h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos= -github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOAGQPoaGhyTchlyt8= -github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE= -github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc= -github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= -github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= +github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= +github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= +github.com/prometheus/common v0.60.0 h1:+V9PAREWNvJMAuJ1x1BaWl9dewMW4YrHZQbx0sJNllA= +github.com/prometheus/common v0.60.0/go.mod h1:h0LYf1R1deLSKtD4Vdg8gy4RuOvENW2J/h19V5NADQw= +github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= +github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= github.com/prometheus/prometheus v0.50.1 h1:N2L+DYrxqPh4WZStU+o1p/gQlBaqFbcLBTjlp3vpdXw= github.com/prometheus/prometheus v0.50.1/go.mod h1:FvE8dtQ1Ww63IlyKBn1V4s+zMwF9kHkVNkQBR1pM4CU= github.com/prometheus/statsd_exporter v0.22.7 h1:7Pji/i2GuhK6Lu7DHrtTkFmNBCudCPT1pX2CziuyQR0= github.com/prometheus/statsd_exporter v0.22.7/go.mod h1:N/TevpjkIh9ccs6nuzY3jQn9dFqnUakOjnEuMPJJJnI= +github.com/rcrowley/go-metrics v0.0.0-20141108142129-dee209f2455f h1:dfcuI1ZZzn8OXb0mYeJFo/0FzL/9eXT/sEzogrOzGc8= +github.com/rcrowley/go-metrics v0.0.0-20141108142129-dee209f2455f/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8= github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/robfig/cron v1.2.0 h1:ZjScXvvxeQ63Dbyxy76Fj3AT3Ut0aKsyd2/tl3DTMuQ= github.com/robfig/cron v1.2.0/go.mod h1:JGuDeoQd7Z6yL4zQhZ3OPEVHB7fL6Ka6skscFHfmt2k= +github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs= +github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= -github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= -github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII= +github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o= github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc= github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/samuel/go-thrift v0.0.0-20190219015601-e8b6b52668fe/go.mod h1:Vrkh1pnjV9Bl8c3P9zH0/D4NlOHWP5d4/hF4YTULaec= github.com/sebest/xff v0.0.0-20210106013422-671bd2870b3a h1:iLcLb5Fwwz7g/DLK89F+uQBDeAhHhwdzB5fSlVdhGcM= github.com/sebest/xff v0.0.0-20210106013422-671bd2870b3a/go.mod h1:wozgYq9WEBQBaIJe4YZ0qTSFAMxmcwBhQH0fO0R34Z0= github.com/sethvargo/go-envconfig v1.1.0 h1:cWZiJxeTm7AlCvzGXrEXaSTCNgip5oJepekh/BOQuog= @@ -553,12 +620,15 @@ github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFt github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ= github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU= github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k= +github.com/sirupsen/logrus v1.0.2-0.20170726183946-abee6f9b0679/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= github.com/smartystreets/assertions v1.1.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo= github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= +github.com/sony/gobreaker v1.0.0 h1:feX5fGGXSl3dYd4aHZItw+FpHLvvoaqkawKjVNiFMNQ= +github.com/sony/gobreaker v1.0.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= github.com/spf13/afero v0.0.0-20170901052352-ee1bd8ee15a1/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= github.com/spf13/cast v1.1.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg= github.com/spf13/cast v1.5.1 h1:R+kOtfhWQE6TVQzY+4D7wJLBgkdVasCEFxSUBYBYIlA= @@ -587,14 +657,22 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/swaggo/files v1.0.1 h1:J1bVJ4XHZNq0I46UU90611i9/YzdrF7x92oX1ig5IdE= github.com/swaggo/files v1.0.1/go.mod h1:0qXmMNH6sXNf+73t65aKeB+ApmgxdnkQzVTAj2uaMUg= github.com/swaggo/gin-swagger v1.6.0 h1:y8sxvQ3E20/RCyrXeFfg60r6H0Z+SwpTjMYsMm+zy8M= github.com/swaggo/gin-swagger v1.6.0/go.mod h1:BG00cCEy294xtVpyIAHG6+e2Qzj/xKlRdOqDkvq0uzo= github.com/swaggo/swag v1.16.2 h1:28Pp+8DkQoV+HLzLx8RGJZXNGKbFqnuvSbAAtoxiY04= github.com/swaggo/swag v1.16.2/go.mod h1:6YzXnDcpr0767iOejs318CwYkCQqyGer6BizOg03f+E= +github.com/temporalio/ringpop-go v0.0.0-20241119001152-e505ebd8f887 h1:08Y1jDl4UKVu+TiQHIVKcW6TKQaHl15vBKkcZ094/SA= +github.com/temporalio/ringpop-go v0.0.0-20241119001152-e505ebd8f887/go.mod h1:RE+CHmY+kOZQk47AQaVzwrGmxpflnLgTd6EOK0853j4= +github.com/temporalio/sqlparser v0.0.0-20231115171017-f4060bcfa6cb h1:YzHH/U/dN7vMP+glybzcXRTczTrgfdRisNTzAj7La04= +github.com/temporalio/sqlparser v0.0.0-20231115171017-f4060bcfa6cb/go.mod h1:143qKdh3G45IgV9p+gbAwp3ikRDI8mxsijFiXDfuxsw= +github.com/temporalio/tchannel-go v1.22.1-0.20220818200552-1be8d8cffa5b/go.mod h1:c+V9Z/ZgkzAdyGvHrvC5AsXgN+M9Qwey04cBdKYzV7U= +github.com/temporalio/tchannel-go v1.22.1-0.20240528171429-1db37fdea938 h1:sEJGhmDo+0FaPWM6f0v8Tjia0H5pR6/Baj6+kS78B+M= +github.com/temporalio/tchannel-go v1.22.1-0.20240528171429-1db37fdea938/go.mod h1:ezRQRwu9KQXy8Wuuv1aaFFxoCNz5CeNbVOOkh3xctbY= github.com/testcontainers/testcontainers-go v0.34.0 h1:5fbgF0vIN5u+nD3IWabQwRybuB4GY8G2HHgCkbMzMHo= github.com/testcontainers/testcontainers-go v0.34.0/go.mod h1:6P/kMkQe8yqPHfPWNulFGdFHTD8HB2vLq/231xY2iPQ= github.com/testcontainers/testcontainers-go/modules/mysql v0.32.0 h1:6vjJOVJSWDTyNvQmB8EFTmv20ScquRWZa+pM1hZNodc= @@ -616,6 +694,14 @@ github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc h1:9lRDQMhESg+zvGYm github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc/go.mod h1:bciPuU6GHm1iF1pBvUfxfsH0Wmnc2VbpgvbI9ZWuIRs= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= +github.com/twmb/murmur3 v1.1.8 h1:8Yt9taO/WN3l08xErzjeschgZU2QSrwm1kclYq+0aRg= +github.com/twmb/murmur3 v1.1.8/go.mod h1:Qq/R7NUyOfr65zD+6Q5IHKsJLwP7exErjN6lyyq3OSQ= +github.com/uber-common/bark v1.0.0 h1:l5mfssVFEaYr60U8c4LNLRkp6xo6pTcOAcB1aJ4f9+g= +github.com/uber-common/bark v1.0.0/go.mod h1:g0ZuPcD7XiExKHynr93Q742G/sbrdVQkghrqLGOoFuY= +github.com/uber-go/tally v3.3.15+incompatible/go.mod h1:YDTIBxdXyOU/sCWilKB4bgyufu1cEi0jdVnRdxvjnmU= +github.com/uber-go/tally/v4 v4.1.17-0.20240412215630-22fe011f5ff0 h1:z5IgRoL16N7tdzn5oikX2G4oVXopW+CWo3XRxx61OQo= +github.com/uber-go/tally/v4 v4.1.17-0.20240412215630-22fe011f5ff0/go.mod h1:ZdpiHRGSa3z4NIAc1VlEH4SiknR885fOIF08xmS0gaU= +github.com/uber/jaeger-client-go v2.22.1+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk= github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o= github.com/uber/jaeger-client-go v2.30.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk= github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg= @@ -658,44 +744,63 @@ gitlab.com/gitlab-org/labkit v1.21.2/go.mod h1:Q++SWyCH/abH2pytnX2SU/3mrCX6aK/xK go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 h1:4Pp6oUg3+e/6M4C0A/3kJ2VYa++dsWVTtGgLVj5xtHg= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0/go.mod h1:Mjt1i1INqiaoZOMGR1RIUJN+i3ChKoFRqzrRQhlkbs0= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= -go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= -go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.22.0 h1:9M3+rhx7kZCIQQhQRYaZCdNu1V73tm4TvXs2ntl98C4= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.22.0/go.mod h1:noq80iT8rrHP1SfybmPiRGc9dc5M8RPmGvtwo7Oo7tc= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.56.0 h1:yMkBS9yViCc7U7yeLzJPM2XizlfdVvBRSmsQDWu6qc0= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.56.0/go.mod h1:n8MR6/liuGB5EmTETUBeU5ZgqMOlqKRxUaqPQBOANZ8= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.52.0 h1:9l89oX4ba9kHbBol3Xin3leYJ+252h0zszDtBwyKe2A= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.52.0/go.mod h1:XLZfZboOJWHNKUv7eH0inh0E9VV6eWDFB/9yJyTLPp0= +go.opentelemetry.io/otel v1.31.0 h1:NsJcKPIW0D0H3NgzPDHmo0WW6SptzPdqg/L1zsIm2hY= +go.opentelemetry.io/otel v1.31.0/go.mod h1:O0C14Yl9FgkjqcCZAsE053C13OaddMYr/hz6clDkEJE= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.31.0 h1:FZ6ei8GFW7kyPYdxJaV2rgI6M+4tvZzhYsQ2wgyVC08= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.31.0/go.mod h1:MdEu/mC6j3D+tTEfvI15b5Ci2Fn7NneJ71YMoiS3tpI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.31.0 h1:K0XaT3DwHAcV4nKLzcQvwAgSyisUghWoY20I7huthMk= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.31.0/go.mod h1:B5Ki776z/MBnVha1Nzwp5arlzBbE3+1jk+pGmaP5HME= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.31.0 h1:FFeLy03iVTXP6ffeN2iXrxfGsZGCjVx0/4KlizjyBwU= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.31.0/go.mod h1:TMu73/k1CP8nBUpDLc71Wj/Kf7ZS9FK5b53VapRsP9o= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.22.0 h1:FyjCyI9jVEfqhUh2MoSkmolPjfh5fp2hnV0b0irxH4Q= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.22.0/go.mod h1:hYwym2nDEeZfG/motx0p7L7J1N1vyzIThemQsb4g2qY= -go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= -go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= -go.opentelemetry.io/otel/sdk v1.22.0 h1:6coWHw9xw7EfClIC/+O31R8IY3/+EiRFHevmHafB2Gw= -go.opentelemetry.io/otel/sdk v1.22.0/go.mod h1:iu7luyVGYovrRpe2fmj3CVKouQNdTOkxtLzPvPz1DOc= -go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= -go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= -go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I= -go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM= -go.temporal.io/api v1.40.0 h1:rH3HvUUCFr0oecQTBW5tI6DdDQsX2Xb6OFVgt/bvLto= -go.temporal.io/api v1.40.0/go.mod h1:1WwYUMo6lao8yl0371xWUm13paHExN5ATYT/B7QtFis= -go.temporal.io/sdk v1.30.0 h1:7jzSFZYk+tQ2kIYEP+dvrM7AW9EsCEP52JHCjVGuwbI= -go.temporal.io/sdk v1.30.0/go.mod h1:Pv45F/fVDgWKx+jhix5t/dGgqROVaI+VjPLd3CHWqq0= +go.opentelemetry.io/otel/exporters/prometheus v0.53.0 h1:QXobPHrwiGLM4ufrY3EOmDPJpo2P90UuFau4CDPJA/I= +go.opentelemetry.io/otel/exporters/prometheus v0.53.0/go.mod h1:WOAXGr3D00CfzmFxtTV1eR0GpoHuPEu+HJT8UWW2SIU= +go.opentelemetry.io/otel/metric v1.31.0 h1:FSErL0ATQAmYHUIzSezZibnyVlft1ybhy4ozRPcF2fE= +go.opentelemetry.io/otel/metric v1.31.0/go.mod h1:C3dEloVbLuYoX41KpmAhOqNriGbA+qqH6PQ5E5mUfnY= +go.opentelemetry.io/otel/sdk v1.31.0 h1:xLY3abVHYZ5HSfOg3l2E5LUj2Cwva5Y7yGxnSW9H5Gk= +go.opentelemetry.io/otel/sdk v1.31.0/go.mod h1:TfRbMdhvxIIr/B2N2LQW2S5v9m3gOQ/08KsbbO5BPT0= +go.opentelemetry.io/otel/sdk/metric v1.31.0 h1:i9hxxLJF/9kkvfHppyLL55aW7iIJz4JjxTeYusH7zMc= +go.opentelemetry.io/otel/sdk/metric v1.31.0/go.mod h1:CRInTMVvNhUKgSAMbKyTMxqOBC0zgyxzW55lZzX43Y8= +go.opentelemetry.io/otel/trace v1.31.0 h1:ffjsj1aRouKewfr85U2aGagJ46+MvodynlQ1HYdmJys= +go.opentelemetry.io/otel/trace v1.31.0/go.mod h1:TXZkRk7SM2ZQLtR6eoAWQFIHPvzQ06FJAsO1tJg480A= +go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0= +go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8= +go.temporal.io/api v1.43.0 h1:lBhq+u5qFJqGMXwWsmg/i8qn1UA/3LCwVc88l2xUMHg= +go.temporal.io/api v1.43.0/go.mod h1:1WwYUMo6lao8yl0371xWUm13paHExN5ATYT/B7QtFis= +go.temporal.io/sdk v1.31.0 h1:CLYiP0R5Sdj0gq8LyYKDDz4ccGOdJPR8wNGJU0JGwj8= +go.temporal.io/sdk v1.31.0/go.mod h1:8U8H7rF9u4Hyb4Ry9yiEls5716DHPNvVITPNkgWUwE8= +go.temporal.io/server v1.26.2 h1:vDW11lxslYPlGDbQklWi/tqbkVZ2ExtRO1jNjvZmUUI= +go.temporal.io/server v1.26.2/go.mod h1:tgY+4z/PuIdqs6ouV1bT90RWSWfEioWkzmrNrLYLUrk= +go.temporal.io/version v0.3.0 h1:dMrei9l9NyHt8nG6EB8vAwDLLTwx2SvRyucCSumAiig= +go.temporal.io/version v0.3.0/go.mod h1:UA9S8/1LaKYae6TyD9NaPMJTZb911JcbqghI2CBSP78= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/dig v1.17.1 h1:Tga8Lz8PcYNsWsyHMZ1Vm0OQOUaJNDyvPImgbAu9YSc= +go.uber.org/dig v1.17.1/go.mod h1:Us0rSJiThwCv2GteUN0Q7OKvU7n5J4dxZ9JKUXozFdE= +go.uber.org/fx v1.22.0 h1:pApUK7yL0OUHMd8vkunWSlLxZVFFk70jR2nKde8X2NM= +go.uber.org/fx v1.22.0/go.mod h1:HT2M7d7RHo+ebKGh9NRcrsrHHfpZ60nW3QRubMRfv48= go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= -go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= -go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc= golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= @@ -721,8 +826,8 @@ golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= -golang.org/x/exp v0.0.0-20240119083558-1b970713d09a h1:Q8/wZp0KX97QFTc2ywcOE0YRjZPVIx+MXInMzdvQqcA= -golang.org/x/exp v0.0.0-20240119083558-1b970713d09a/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08= +golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc h1:O9NuF4s+E/PvMIy+9IUZB9znFwUIXEWSstNjek6VpVg= +golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= @@ -762,6 +867,7 @@ golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= @@ -771,13 +877,13 @@ golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ= golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk= golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= -golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= -golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= +golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo= +golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM= golang.org/x/oauth2 v0.0.0-20170912212905-13449ad91cb2/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.22.0 h1:BzDx2FehcG7jJwgWLELCdmLuxk2i+x9UDpSiss2u0ZA= -golang.org/x/oauth2 v0.22.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= +golang.org/x/oauth2 v0.23.0 h1:PbgcYx2W7i4LvjJWEbf0ngHV6qJYr86PkAV3bXdLEbs= +golang.org/x/oauth2 v0.23.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= golang.org/x/sync v0.0.0-20170517211232-f52d1811a629/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -814,11 +920,13 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210217105451-b926d437f341/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -898,8 +1006,8 @@ gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0= gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc= google.golang.org/api v0.0.0-20170921000349-586095a6e407/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0= -google.golang.org/api v0.169.0 h1:QwWPy71FgMWqJN/l6jVlFHUa29a7dcUy02I8o799nPY= -google.golang.org/api v0.169.0/go.mod h1:gpNOiMA2tZ4mf5R9Iwf4rK/Dcz0fbdIgWYWVoxmsyLg= +google.golang.org/api v0.182.0 h1:if5fPvudRQ78GeRx3RayIoiuV7modtErPIZC/T2bIvE= +google.golang.org/api v0.182.0/go.mod h1:cGhjy4caqA5yXRzEhkHI8Y9mfyC2VLTlER2l08xaqtM= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= @@ -911,12 +1019,12 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98 google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20240311173647-c811ad7063a7 h1:ImUcDPHjTrAqNhlOkSocDLfG9rrNHH7w7uoKWPaWZ8s= -google.golang.org/genproto v0.0.0-20240311173647-c811ad7063a7/go.mod h1:/3XmxOjePkvmKrHuBy4zNFw7IzxJXtAgdpXi8Ll990U= -google.golang.org/genproto/googleapis/api v0.0.0-20240827150818-7e3bb234dfed h1:3RgNmBoI9MZhsj3QxC+AP/qQhNwpCLOvYDYYsFrhFt0= -google.golang.org/genproto/googleapis/api v0.0.0-20240827150818-7e3bb234dfed/go.mod h1:OCdP9MfskevB/rbYvHTsXTtKC+3bHWajPdoKgjcYkfo= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240827150818-7e3bb234dfed h1:J6izYgfBXAI3xTKLgxzTmUltdYaLsuBxFCgDHWJ/eXg= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240827150818-7e3bb234dfed/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/genproto v0.0.0-20240528184218-531527333157 h1:u7WMYrIrVvs0TF5yaKwKNbcJyySYf+HAIFXxWltJOXE= +google.golang.org/genproto v0.0.0-20240528184218-531527333157/go.mod h1:ubQlAQnzejB8uZzszhrTCU2Fyp6Vi7ZE5nn0c3W8+qQ= +google.golang.org/genproto/googleapis/api v0.0.0-20241007155032-5fefd90f89a9 h1:T6rh4haD3GVYsgEfWExoCZA2o2FmbNyKpTuAxbEFPTg= +google.golang.org/genproto/googleapis/api v0.0.0-20241007155032-5fefd90f89a9/go.mod h1:wp2WsuBYj6j8wUdo3ToZsdxxixbvQNAHqVJrTgi5E5M= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 h1:QCqS/PdaHTSWGvupk2F/ehwHtGc0/GYkT+3GAcR1CCc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI= google.golang.org/grpc v1.2.1-0.20170921194603-d4b75ebd4f9f/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= @@ -928,8 +1036,8 @@ google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3Iji google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.66.0 h1:DibZuoBznOxbDQxRINckZcUvnCEvrW9pcWIE2yF9r1c= -google.golang.org/grpc v1.66.0/go.mod h1:s3/l6xSSCURdVfAnL+TqCNMyTDAGN6+lZeVxnZR128Y= +google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E= +google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -941,8 +1049,8 @@ google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpAD google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA= +google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= gopkg.in/DataDog/dd-trace-go.v1 v1.32.0 h1:DkD0plWEVUB8v/Ru6kRBW30Hy/fRNBC8hPdcExuBZMc= gopkg.in/DataDog/dd-trace-go.v1 v1.32.0/go.mod h1:wRKMf/tRASHwH/UOfPQ3IQmVFhTz2/1a1/mpXoIjF54= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -954,6 +1062,8 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EV gopkg.in/evanphx/json-patch.v4 v4.12.0 h1:n6jtcsulIzXPJaxegRbvFNNrZDjbij7ny3gmSPG+6V4= gopkg.in/evanphx/json-patch.v4 v4.12.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/go-jose/go-jose.v2 v2.6.3 h1:nt80fvSDlhKWQgSWyHyy5CfmlQr+asih51R8PTWNKKs= +gopkg.in/go-jose/go-jose.v2 v2.6.3/go.mod h1:zzZDPkNNw/c9IE7Z9jr11mBZQhKQTMzoEEIoEdZlFBI= gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= gopkg.in/ini.v1 v1.56.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= @@ -962,6 +1072,8 @@ gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/validator.v2 v2.0.1 h1:xF0KWyGWXm/LM2G1TrEjqOu4pa6coO9AlWSf3msVfDY= +gopkg.in/validator.v2 v2.0.1/go.mod h1:lIUZBlB3Im4s/eYp39Ry/wkR02yOPhZ9IwIRBjuPuG8= gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= @@ -999,16 +1111,28 @@ knative.dev/serving v0.40.1 h1:ZAAK8KwZQYUgCgVi3ay+NqKAISnJQ1OXPYvdtXWUcBc= knative.dev/serving v0.40.1/go.mod h1:Ory3XczDB8b1lH757CSdeDeouY3LHzSamX8IjmStuoU= mellium.im/sasl v0.3.1 h1:wE0LW6g7U83vhvxjC1IY8DnXM+EU095yeo8XClvCdfo= mellium.im/sasl v0.3.1/go.mod h1:xm59PUYpZHhgQ9ZqoJ5QaCqzWMi8IeS49dhp6plPCzw= -modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI= -modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= -modernc.org/libc v1.41.0 h1:g9YAc6BkKlgORsUWj+JwqoB1wU3o4DE3bM3yvA3k+Gk= -modernc.org/libc v1.41.0/go.mod h1:w0eszPsiXoOnoMJgrXjglgLuDy/bt5RR4y3QzUUeodY= +modernc.org/cc/v4 v4.21.4 h1:3Be/Rdo1fpr8GrQ7IVw9OHtplU4gWbb+wNgeoBMmGLQ= +modernc.org/cc/v4 v4.21.4/go.mod h1:HM7VJTZbUCR3rV8EYBi9wxnJ0ZBRiGE5OeGXNA0IsLQ= +modernc.org/ccgo/v4 v4.19.2 h1:lwQZgvboKD0jBwdaeVCTouxhxAyN6iawF3STraAal8Y= +modernc.org/ccgo/v4 v4.19.2/go.mod h1:ysS3mxiMV38XGRTTcgo0DQTeTmAO4oCmJl1nX9VFI3s= +modernc.org/fileutil v1.3.0 h1:gQ5SIzK3H9kdfai/5x41oQiKValumqNTDXMvKo62HvE= +modernc.org/fileutil v1.3.0/go.mod h1:XatxS8fZi3pS8/hKG2GH/ArUogfxjpEKs3Ku3aK4JyQ= +modernc.org/gc/v2 v2.4.1 h1:9cNzOqPyMJBvrUipmynX0ZohMhcxPtMccYgGOJdOiBw= +modernc.org/gc/v2 v2.4.1/go.mod h1:wzN5dK1AzVGoH6XOzc3YZ+ey/jPgYHLuVckd62P0GYU= +modernc.org/gc/v3 v3.0.0-20240304020402-f0dba7c97c2b h1:BnN1t+pb1cy61zbvSUV7SeI0PwosMhlAEi/vBY4qxp8= +modernc.org/gc/v3 v3.0.0-20240304020402-f0dba7c97c2b/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= +modernc.org/libc v1.55.3 h1:AzcW1mhlPNrRtjS5sS+eW2ISCgSOLLNyFzRh/V3Qj/U= +modernc.org/libc v1.55.3/go.mod h1:qFXepLhz+JjFThQ4kzwzOjA/y/artDeg+pcYnY+Q83w= modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= -modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E= -modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E= -modernc.org/sqlite v1.29.1 h1:19GY2qvWB4VPw0HppFlZCPAbmxFU41r+qjKZQdQ1ryA= -modernc.org/sqlite v1.29.1/go.mod h1:hG41jCYxOAOoO6BRK66AdRlmOcDzXf7qnwlwjUIOqa0= +modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E= +modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU= +modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4= +modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= +modernc.org/sortutil v1.2.0 h1:jQiD3PfS2REGJNzNCMMaLSp/wdMNieTbKX920Cqdgqc= +modernc.org/sortutil v1.2.0/go.mod h1:TKU2s7kJMf1AE84OoiGppNHJwvB753OYfNl2WRb++Ss= +modernc.org/sqlite v1.34.1 h1:u3Yi6M0N8t9yKRDwhXcyp1eS5/ErhPTBggxWFuR6Hfk= +modernc.org/sqlite v1.34.1/go.mod h1:pXV2xHxhzXZsgT/RtTFAPY6JJDEvOTcTdwADQCCWD4k= modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/mirror/reposyncer/local_woker.go b/mirror/reposyncer/local_woker.go index 530630b6..b6a98c11 100644 --- a/mirror/reposyncer/local_woker.go +++ b/mirror/reposyncer/local_woker.go @@ -15,6 +15,7 @@ import ( "opencsg.com/csghub-server/builder/git/gitserver" "opencsg.com/csghub-server/builder/git/gitserver/gitaly" "opencsg.com/csghub-server/builder/store/database" + "opencsg.com/csghub-server/builder/temporal" "opencsg.com/csghub-server/common/config" "opencsg.com/csghub-server/common/types" "opencsg.com/csghub-server/mirror/queue" @@ -227,14 +228,13 @@ func (w *LocalMirrorWoker) SyncRepo(ctx context.Context, task queue.MirrorTask) callback.Ref = branch //start workflow to handle push request - workflowClient := workflow.GetWorkflowClient() + workflowClient := temporal.GetClient() workflowOptions := client.StartWorkflowOptions{ TaskQueue: workflow.HandlePushQueueName, } - we, err := workflowClient.ExecuteWorkflow(ctx, workflowOptions, workflow.HandlePushWorkflow, - callback, - w.config, + we, err := workflowClient.ExecuteWorkflow( + ctx, workflowOptions, workflow.HandlePushWorkflow, callback, ) if err != nil { return fmt.Errorf("failed to handle git push callback: %w", err)