diff --git a/client/frontend/client_gen.go b/client/frontend/client_gen.go index c1dd736d517..c72793f75b2 100644 --- a/client/frontend/client_gen.go +++ b/client/frontend/client_gen.go @@ -579,6 +579,16 @@ func (c *clientImpl) PauseActivity( return c.client.PauseActivity(ctx, request, opts...) } +func (c *clientImpl) PauseActivityExecution( + ctx context.Context, + request *workflowservice.PauseActivityExecutionRequest, + opts ...grpc.CallOption, +) (*workflowservice.PauseActivityExecutionResponse, error) { + ctx, cancel := c.createContext(ctx) + defer cancel() + return c.client.PauseActivityExecution(ctx, request, opts...) +} + func (c *clientImpl) PauseWorkflowExecution( ctx context.Context, request *workflowservice.PauseWorkflowExecutionRequest, @@ -739,6 +749,16 @@ func (c *clientImpl) ResetActivity( return c.client.ResetActivity(ctx, request, opts...) } +func (c *clientImpl) ResetActivityExecution( + ctx context.Context, + request *workflowservice.ResetActivityExecutionRequest, + opts ...grpc.CallOption, +) (*workflowservice.ResetActivityExecutionResponse, error) { + ctx, cancel := c.createContext(ctx) + defer cancel() + return c.client.ResetActivityExecution(ctx, request, opts...) +} + func (c *clientImpl) ResetStickyTaskQueue( ctx context.Context, request *workflowservice.ResetStickyTaskQueueRequest, @@ -1049,6 +1069,16 @@ func (c *clientImpl) UnpauseActivity( return c.client.UnpauseActivity(ctx, request, opts...) } +func (c *clientImpl) UnpauseActivityExecution( + ctx context.Context, + request *workflowservice.UnpauseActivityExecutionRequest, + opts ...grpc.CallOption, +) (*workflowservice.UnpauseActivityExecutionResponse, error) { + ctx, cancel := c.createContext(ctx) + defer cancel() + return c.client.UnpauseActivityExecution(ctx, request, opts...) +} + func (c *clientImpl) UnpauseWorkflowExecution( ctx context.Context, request *workflowservice.UnpauseWorkflowExecutionRequest, @@ -1059,6 +1089,16 @@ func (c *clientImpl) UnpauseWorkflowExecution( return c.client.UnpauseWorkflowExecution(ctx, request, opts...) } +func (c *clientImpl) UpdateActivityExecutionOptions( + ctx context.Context, + request *workflowservice.UpdateActivityExecutionOptionsRequest, + opts ...grpc.CallOption, +) (*workflowservice.UpdateActivityExecutionOptionsResponse, error) { + ctx, cancel := c.createContext(ctx) + defer cancel() + return c.client.UpdateActivityExecutionOptions(ctx, request, opts...) +} + func (c *clientImpl) UpdateActivityOptions( ctx context.Context, request *workflowservice.UpdateActivityOptionsRequest, diff --git a/client/frontend/metric_client_gen.go b/client/frontend/metric_client_gen.go index 1595908bcbd..247c90a2ed9 100644 --- a/client/frontend/metric_client_gen.go +++ b/client/frontend/metric_client_gen.go @@ -807,6 +807,20 @@ func (c *metricClient) PauseActivity( return c.client.PauseActivity(ctx, request, opts...) } +func (c *metricClient) PauseActivityExecution( + ctx context.Context, + request *workflowservice.PauseActivityExecutionRequest, + opts ...grpc.CallOption, +) (_ *workflowservice.PauseActivityExecutionResponse, retError error) { + + metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientPauseActivityExecution") + defer func() { + c.finishMetricsRecording(metricsHandler, startTime, retError) + }() + + return c.client.PauseActivityExecution(ctx, request, opts...) +} + func (c *metricClient) PauseWorkflowExecution( ctx context.Context, request *workflowservice.PauseWorkflowExecutionRequest, @@ -1031,6 +1045,20 @@ func (c *metricClient) ResetActivity( return c.client.ResetActivity(ctx, request, opts...) } +func (c *metricClient) ResetActivityExecution( + ctx context.Context, + request *workflowservice.ResetActivityExecutionRequest, + opts ...grpc.CallOption, +) (_ *workflowservice.ResetActivityExecutionResponse, retError error) { + + metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientResetActivityExecution") + defer func() { + c.finishMetricsRecording(metricsHandler, startTime, retError) + }() + + return c.client.ResetActivityExecution(ctx, request, opts...) +} + func (c *metricClient) ResetStickyTaskQueue( ctx context.Context, request *workflowservice.ResetStickyTaskQueueRequest, @@ -1465,6 +1493,20 @@ func (c *metricClient) UnpauseActivity( return c.client.UnpauseActivity(ctx, request, opts...) } +func (c *metricClient) UnpauseActivityExecution( + ctx context.Context, + request *workflowservice.UnpauseActivityExecutionRequest, + opts ...grpc.CallOption, +) (_ *workflowservice.UnpauseActivityExecutionResponse, retError error) { + + metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientUnpauseActivityExecution") + defer func() { + c.finishMetricsRecording(metricsHandler, startTime, retError) + }() + + return c.client.UnpauseActivityExecution(ctx, request, opts...) +} + func (c *metricClient) UnpauseWorkflowExecution( ctx context.Context, request *workflowservice.UnpauseWorkflowExecutionRequest, @@ -1479,6 +1521,20 @@ func (c *metricClient) UnpauseWorkflowExecution( return c.client.UnpauseWorkflowExecution(ctx, request, opts...) } +func (c *metricClient) UpdateActivityExecutionOptions( + ctx context.Context, + request *workflowservice.UpdateActivityExecutionOptionsRequest, + opts ...grpc.CallOption, +) (_ *workflowservice.UpdateActivityExecutionOptionsResponse, retError error) { + + metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientUpdateActivityExecutionOptions") + defer func() { + c.finishMetricsRecording(metricsHandler, startTime, retError) + }() + + return c.client.UpdateActivityExecutionOptions(ctx, request, opts...) +} + func (c *metricClient) UpdateActivityOptions( ctx context.Context, request *workflowservice.UpdateActivityOptionsRequest, diff --git a/client/frontend/retryable_client_gen.go b/client/frontend/retryable_client_gen.go index b062c5393de..7a5a63cf4de 100644 --- a/client/frontend/retryable_client_gen.go +++ b/client/frontend/retryable_client_gen.go @@ -866,6 +866,21 @@ func (c *retryableClient) PauseActivity( return resp, err } +func (c *retryableClient) PauseActivityExecution( + ctx context.Context, + request *workflowservice.PauseActivityExecutionRequest, + opts ...grpc.CallOption, +) (*workflowservice.PauseActivityExecutionResponse, error) { + var resp *workflowservice.PauseActivityExecutionResponse + op := func(ctx context.Context) error { + var err error + resp, err = c.client.PauseActivityExecution(ctx, request, opts...) + return err + } + err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable) + return resp, err +} + func (c *retryableClient) PauseWorkflowExecution( ctx context.Context, request *workflowservice.PauseWorkflowExecutionRequest, @@ -1106,6 +1121,21 @@ func (c *retryableClient) ResetActivity( return resp, err } +func (c *retryableClient) ResetActivityExecution( + ctx context.Context, + request *workflowservice.ResetActivityExecutionRequest, + opts ...grpc.CallOption, +) (*workflowservice.ResetActivityExecutionResponse, error) { + var resp *workflowservice.ResetActivityExecutionResponse + op := func(ctx context.Context) error { + var err error + resp, err = c.client.ResetActivityExecution(ctx, request, opts...) + return err + } + err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable) + return resp, err +} + func (c *retryableClient) ResetStickyTaskQueue( ctx context.Context, request *workflowservice.ResetStickyTaskQueueRequest, @@ -1571,6 +1601,21 @@ func (c *retryableClient) UnpauseActivity( return resp, err } +func (c *retryableClient) UnpauseActivityExecution( + ctx context.Context, + request *workflowservice.UnpauseActivityExecutionRequest, + opts ...grpc.CallOption, +) (*workflowservice.UnpauseActivityExecutionResponse, error) { + var resp *workflowservice.UnpauseActivityExecutionResponse + op := func(ctx context.Context) error { + var err error + resp, err = c.client.UnpauseActivityExecution(ctx, request, opts...) + return err + } + err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable) + return resp, err +} + func (c *retryableClient) UnpauseWorkflowExecution( ctx context.Context, request *workflowservice.UnpauseWorkflowExecutionRequest, @@ -1586,6 +1631,21 @@ func (c *retryableClient) UnpauseWorkflowExecution( return resp, err } +func (c *retryableClient) UpdateActivityExecutionOptions( + ctx context.Context, + request *workflowservice.UpdateActivityExecutionOptionsRequest, + opts ...grpc.CallOption, +) (*workflowservice.UpdateActivityExecutionOptionsResponse, error) { + var resp *workflowservice.UpdateActivityExecutionOptionsResponse + op := func(ctx context.Context) error { + var err error + resp, err = c.client.UpdateActivityExecutionOptions(ctx, request, opts...) + return err + } + err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable) + return resp, err +} + func (c *retryableClient) UpdateActivityOptions( ctx context.Context, request *workflowservice.UpdateActivityOptionsRequest, diff --git a/common/api/metadata.go b/common/api/metadata.go index 0cbd03bd93d..bb584d38000 100644 --- a/common/api/metadata.go +++ b/common/api/metadata.go @@ -153,6 +153,10 @@ var ( "PauseActivity": {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone}, "UnpauseActivity": {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone}, "ResetActivity": {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone}, + "UpdateActivityExecutionOptions": {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone}, + "PauseActivityExecution": {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone}, + "UnpauseActivityExecution": {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone}, + "ResetActivityExecution": {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone}, "UpdateWorkflowExecutionOptions": {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone}, "DescribeDeployment": {Scope: ScopeNamespace, Access: AccessReadOnly, Polling: PollingNone}, // [cleanup-wv-pre-release] "ListDeployments": {Scope: ScopeNamespace, Access: AccessReadOnly, Polling: PollingNone}, // [cleanup-wv-pre-release] diff --git a/common/rpc/interceptor/logtags/workflow_service_server_gen.go b/common/rpc/interceptor/logtags/workflow_service_server_gen.go index b0d76247797..a03c1e7c1f1 100644 --- a/common/rpc/interceptor/logtags/workflow_service_server_gen.go +++ b/common/rpc/interceptor/logtags/workflow_service_server_gen.go @@ -268,6 +268,14 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t } case *workflowservice.PauseActivityResponse: return nil + case *workflowservice.PauseActivityExecutionRequest: + return []tag.Tag{ + tag.WorkflowID(r.GetWorkflowId()), + tag.ActivityID(r.GetActivityId()), + tag.WorkflowRunID(r.GetRunId()), + } + case *workflowservice.PauseActivityExecutionResponse: + return nil case *workflowservice.PauseWorkflowExecutionRequest: return []tag.Tag{ tag.WorkflowID(r.GetWorkflowId()), @@ -376,6 +384,14 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t } case *workflowservice.ResetActivityResponse: return nil + case *workflowservice.ResetActivityExecutionRequest: + return []tag.Tag{ + tag.WorkflowID(r.GetWorkflowId()), + tag.ActivityID(r.GetActivityId()), + tag.WorkflowRunID(r.GetRunId()), + } + case *workflowservice.ResetActivityExecutionResponse: + return nil case *workflowservice.ResetStickyTaskQueueRequest: return []tag.Tag{ tag.WorkflowID(r.GetExecution().GetWorkflowId()), @@ -554,6 +570,14 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t } case *workflowservice.UnpauseActivityResponse: return nil + case *workflowservice.UnpauseActivityExecutionRequest: + return []tag.Tag{ + tag.WorkflowID(r.GetWorkflowId()), + tag.ActivityID(r.GetActivityId()), + tag.WorkflowRunID(r.GetRunId()), + } + case *workflowservice.UnpauseActivityExecutionResponse: + return nil case *workflowservice.UnpauseWorkflowExecutionRequest: return []tag.Tag{ tag.WorkflowID(r.GetWorkflowId()), @@ -561,6 +585,14 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t } case *workflowservice.UnpauseWorkflowExecutionResponse: return nil + case *workflowservice.UpdateActivityExecutionOptionsRequest: + return []tag.Tag{ + tag.WorkflowID(r.GetWorkflowId()), + tag.ActivityID(r.GetActivityId()), + tag.WorkflowRunID(r.GetRunId()), + } + case *workflowservice.UpdateActivityExecutionOptionsResponse: + return nil case *workflowservice.UpdateActivityOptionsRequest: return []tag.Tag{ tag.WorkflowID(r.GetExecution().GetWorkflowId()), diff --git a/common/rpc/interceptor/redirection.go b/common/rpc/interceptor/redirection.go index 21cf41c8dfa..05e3bc73cf5 100644 --- a/common/rpc/interceptor/redirection.go +++ b/common/rpc/interceptor/redirection.go @@ -110,6 +110,10 @@ var ( "PauseActivity": func() any { return &workflowservice.PauseActivityResponse{} }, "UnpauseActivity": func() any { return &workflowservice.UnpauseActivityResponse{} }, "ResetActivity": func() any { return &workflowservice.ResetActivityResponse{} }, + "UpdateActivityExecutionOptions": func() any { return &workflowservice.UpdateActivityExecutionOptionsResponse{} }, + "PauseActivityExecution": func() any { return &workflowservice.PauseActivityExecutionResponse{} }, + "UnpauseActivityExecution": func() any { return &workflowservice.UnpauseActivityExecutionResponse{} }, + "ResetActivityExecution": func() any { return &workflowservice.ResetActivityExecutionResponse{} }, "UpdateWorkflowExecutionOptions": func() any { return &workflowservice.UpdateWorkflowExecutionOptionsResponse{} }, "DescribeDeployment": func() any { return &workflowservice.DescribeDeploymentResponse{} }, // [cleanup-wv-pre-release] diff --git a/common/rpc/interceptor/redirection_test.go b/common/rpc/interceptor/redirection_test.go index 9ba7201689d..ddc180b4b00 100644 --- a/common/rpc/interceptor/redirection_test.go +++ b/common/rpc/interceptor/redirection_test.go @@ -169,6 +169,10 @@ func (s *redirectionInterceptorSuite) TestGlobalAPI() { "PauseActivity": {}, "UnpauseActivity": {}, "ResetActivity": {}, + "UpdateActivityExecutionOptions": {}, + "PauseActivityExecution": {}, + "UnpauseActivityExecution": {}, + "ResetActivityExecution": {}, "UpdateWorkflowExecutionOptions": {}, "DescribeDeployment": {}, "ListDeployments": {}, diff --git a/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go b/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go index 785d81bb6cb..34a676ad5a9 100644 --- a/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go +++ b/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go @@ -1182,6 +1182,26 @@ func (mr *MockWorkflowServiceClientMockRecorder) PauseActivity(ctx, in any, opts return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseActivity", reflect.TypeOf((*MockWorkflowServiceClient)(nil).PauseActivity), varargs...) } +// PauseActivityExecution mocks base method. +func (m *MockWorkflowServiceClient) PauseActivityExecution(ctx context.Context, in *workflowservice.PauseActivityExecutionRequest, opts ...grpc.CallOption) (*workflowservice.PauseActivityExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PauseActivityExecution", varargs...) + ret0, _ := ret[0].(*workflowservice.PauseActivityExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PauseActivityExecution indicates an expected call of PauseActivityExecution. +func (mr *MockWorkflowServiceClientMockRecorder) PauseActivityExecution(ctx, in any, opts ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseActivityExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).PauseActivityExecution), varargs...) +} + // PauseWorkflowExecution mocks base method. func (m *MockWorkflowServiceClient) PauseWorkflowExecution(ctx context.Context, in *workflowservice.PauseWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.PauseWorkflowExecutionResponse, error) { m.ctrl.T.Helper() @@ -1502,6 +1522,26 @@ func (mr *MockWorkflowServiceClientMockRecorder) ResetActivity(ctx, in any, opts return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetActivity", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ResetActivity), varargs...) } +// ResetActivityExecution mocks base method. +func (m *MockWorkflowServiceClient) ResetActivityExecution(ctx context.Context, in *workflowservice.ResetActivityExecutionRequest, opts ...grpc.CallOption) (*workflowservice.ResetActivityExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetActivityExecution", varargs...) + ret0, _ := ret[0].(*workflowservice.ResetActivityExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetActivityExecution indicates an expected call of ResetActivityExecution. +func (mr *MockWorkflowServiceClientMockRecorder) ResetActivityExecution(ctx, in any, opts ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetActivityExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ResetActivityExecution), varargs...) +} + // ResetStickyTaskQueue mocks base method. func (m *MockWorkflowServiceClient) ResetStickyTaskQueue(ctx context.Context, in *workflowservice.ResetStickyTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.ResetStickyTaskQueueResponse, error) { m.ctrl.T.Helper() @@ -2122,6 +2162,26 @@ func (mr *MockWorkflowServiceClientMockRecorder) UnpauseActivity(ctx, in any, op return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpauseActivity", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UnpauseActivity), varargs...) } +// UnpauseActivityExecution mocks base method. +func (m *MockWorkflowServiceClient) UnpauseActivityExecution(ctx context.Context, in *workflowservice.UnpauseActivityExecutionRequest, opts ...grpc.CallOption) (*workflowservice.UnpauseActivityExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnpauseActivityExecution", varargs...) + ret0, _ := ret[0].(*workflowservice.UnpauseActivityExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnpauseActivityExecution indicates an expected call of UnpauseActivityExecution. +func (mr *MockWorkflowServiceClientMockRecorder) UnpauseActivityExecution(ctx, in any, opts ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpauseActivityExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UnpauseActivityExecution), varargs...) +} + // UnpauseWorkflowExecution mocks base method. func (m *MockWorkflowServiceClient) UnpauseWorkflowExecution(ctx context.Context, in *workflowservice.UnpauseWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.UnpauseWorkflowExecutionResponse, error) { m.ctrl.T.Helper() @@ -2142,6 +2202,26 @@ func (mr *MockWorkflowServiceClientMockRecorder) UnpauseWorkflowExecution(ctx, i return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpauseWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UnpauseWorkflowExecution), varargs...) } +// UpdateActivityExecutionOptions mocks base method. +func (m *MockWorkflowServiceClient) UpdateActivityExecutionOptions(ctx context.Context, in *workflowservice.UpdateActivityExecutionOptionsRequest, opts ...grpc.CallOption) (*workflowservice.UpdateActivityExecutionOptionsResponse, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateActivityExecutionOptions", varargs...) + ret0, _ := ret[0].(*workflowservice.UpdateActivityExecutionOptionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateActivityExecutionOptions indicates an expected call of UpdateActivityExecutionOptions. +func (mr *MockWorkflowServiceClientMockRecorder) UpdateActivityExecutionOptions(ctx, in any, opts ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivityExecutionOptions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UpdateActivityExecutionOptions), varargs...) +} + // UpdateActivityOptions mocks base method. func (m *MockWorkflowServiceClient) UpdateActivityOptions(ctx context.Context, in *workflowservice.UpdateActivityOptionsRequest, opts ...grpc.CallOption) (*workflowservice.UpdateActivityOptionsResponse, error) { m.ctrl.T.Helper() diff --git a/go.mod b/go.mod index fdd50631d20..dbe232a6248 100644 --- a/go.mod +++ b/go.mod @@ -63,7 +63,7 @@ require ( go.opentelemetry.io/otel/sdk v1.43.0 go.opentelemetry.io/otel/sdk/metric v1.43.0 go.opentelemetry.io/otel/trace v1.43.0 - go.temporal.io/api v1.62.12-0.20260428190948-a7b1d495e2e4 + go.temporal.io/api v1.62.12-0.20260430203359-15c391664683 go.temporal.io/auto-scaled-workers v0.0.0-20260407181057-edd947d743d2 go.temporal.io/sdk v1.41.1 go.uber.org/fx v1.24.0 diff --git a/go.sum b/go.sum index c2f402b0248..957bed1529f 100644 --- a/go.sum +++ b/go.sum @@ -469,8 +469,8 @@ go.opentelemetry.io/proto/slim/otlp/collector/profiles/v1development v0.3.0 h1:R go.opentelemetry.io/proto/slim/otlp/collector/profiles/v1development v0.3.0/go.mod h1:I89cynRj8y+383o7tEQVg2SVA6SRgDVIouWPUVXjx0U= go.opentelemetry.io/proto/slim/otlp/profiles/v1development v0.3.0 h1:CQvJSldHRUN6Z8jsUeYv8J0lXRvygALXIzsmAeCcZE0= go.opentelemetry.io/proto/slim/otlp/profiles/v1development v0.3.0/go.mod h1:xSQ+mEfJe/GjK1LXEyVOoSI1N9JV9ZI923X5kup43W4= -go.temporal.io/api v1.62.12-0.20260428190948-a7b1d495e2e4 h1:AwdQ+0+voxlyZZ54q88ezX0Zzxz2s9H+oSmCf4byy5k= -go.temporal.io/api v1.62.12-0.20260428190948-a7b1d495e2e4/go.mod h1:iaxoP/9OXMJcQkETTECfwYq4cw/bj4nwov8b3ZLVnXM= +go.temporal.io/api v1.62.12-0.20260430203359-15c391664683 h1:GtwQjX9hN0pRjuneBpl/xvcu9Xl9llAt4GjKrlpP0sg= +go.temporal.io/api v1.62.12-0.20260430203359-15c391664683/go.mod h1:iaxoP/9OXMJcQkETTECfwYq4cw/bj4nwov8b3ZLVnXM= go.temporal.io/auto-scaled-workers v0.0.0-20260407181057-edd947d743d2 h1:1hKeH3GyR6YD6LKMHGCZ76t6h1Sgha0hXVQBxWi3dlQ= go.temporal.io/auto-scaled-workers v0.0.0-20260407181057-edd947d743d2/go.mod h1:T8dnzVPeO+gaUTj9eDgm/lT2lZH4+JXNvrGaQGyVi50= go.temporal.io/sdk v1.41.1 h1:yOpvsHyDD1lNuwlGBv/SUodCPhjv9nDeC9lLHW/fJUA= diff --git a/service/frontend/configs/quotas.go b/service/frontend/configs/quotas.go index 7be61ad8777..4d8dcc42c3a 100644 --- a/service/frontend/configs/quotas.go +++ b/service/frontend/configs/quotas.go @@ -121,6 +121,10 @@ var ( "/temporal.api.workflowservice.v1.WorkflowService/PauseActivity": 2, "/temporal.api.workflowservice.v1.WorkflowService/UnpauseActivity": 2, "/temporal.api.workflowservice.v1.WorkflowService/ResetActivity": 2, + "/temporal.api.workflowservice.v1.WorkflowService/UpdateActivityExecutionOptions": 2, + "/temporal.api.workflowservice.v1.WorkflowService/PauseActivityExecution": 2, + "/temporal.api.workflowservice.v1.WorkflowService/UnpauseActivityExecution": 2, + "/temporal.api.workflowservice.v1.WorkflowService/ResetActivityExecution": 2, "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkflowExecutionOptions": 2, "/temporal.api.workflowservice.v1.WorkflowService/SetCurrentDeployment": 2, // [cleanup-wv-pre-release] "/temporal.api.workflowservice.v1.WorkflowService/SetCurrentDeploymentVersion": 2, // [cleanup-wv-pre-release] diff --git a/service/frontend/workflow_handler.go b/service/frontend/workflow_handler.go index 4ab8d51850e..85263168f5f 100644 --- a/service/frontend/workflow_handler.go +++ b/service/frontend/workflow_handler.go @@ -7377,3 +7377,19 @@ func (wh *WorkflowHandler) UnpauseWorkflowExecution(ctx context.Context, request return &workflowservice.UnpauseWorkflowExecutionResponse{}, nil } + +func (wh *WorkflowHandler) PauseActivityExecution(context.Context, *workflowservice.PauseActivityExecutionRequest) (*workflowservice.PauseActivityExecutionResponse, error) { + return nil, serviceerror.NewUnimplemented("PauseActivityExecution not implemented") +} + +func (wh *WorkflowHandler) ResetActivityExecution(context.Context, *workflowservice.ResetActivityExecutionRequest) (*workflowservice.ResetActivityExecutionResponse, error) { + return nil, serviceerror.NewUnimplemented("ResetActivityExecution not implemented") +} + +func (wh *WorkflowHandler) UnpauseActivityExecution(context.Context, *workflowservice.UnpauseActivityExecutionRequest) (*workflowservice.UnpauseActivityExecutionResponse, error) { + return nil, serviceerror.NewUnimplemented("UnpauseActivityExecution not implemented") +} + +func (wh *WorkflowHandler) UpdateActivityExecutionOptions(context.Context, *workflowservice.UpdateActivityExecutionOptionsRequest) (*workflowservice.UpdateActivityExecutionOptionsResponse, error) { + return nil, serviceerror.NewUnimplemented("UpdateActivityExecutionOptions not implemented") +}