From 2f170d7a5220d63f25651800ea920b7687bb4219 Mon Sep 17 00:00:00 2001 From: Yichao Yang Date: Mon, 14 Mar 2022 10:10:46 -0700 Subject: [PATCH 1/4] TerminateIfRunning workflowID reuse policy --- go.mod | 2 + go.sum | 6 - host/signal_workflow_test.go | 28 +++ host/workflow_test.go | 47 +++++ service/history/historyEngine.go | 341 ++++++++++++++++++++----------- tools/cli/flags.go | 2 +- 6 files changed, 297 insertions(+), 129 deletions(-) diff --git a/go.mod b/go.mod index f44b47b4caf..f60444dc57f 100644 --- a/go.mod +++ b/go.mod @@ -61,6 +61,8 @@ require ( gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b ) +replace go.temporal.io/api => /Users/ycyang/temporalio/api-go // TODO: remove after api change is landed + require ( cloud.google.com/go v0.100.2 // indirect cloud.google.com/go/compute v1.2.0 // indirect diff --git a/go.sum b/go.sum index 05fde3d1539..73a3420e91a 100644 --- a/go.sum +++ b/go.sum @@ -476,9 +476,6 @@ go.opentelemetry.io/otel/sdk/metric v0.27.0/go.mod h1:lOgrT5C3ORdbqp2LsDrx+pBj6g go.opentelemetry.io/otel/trace v1.4.0 h1:4OOUrPZdVFQkbzl/JSdvGCWIdw5ONXXxzHlaLlWppmo= go.opentelemetry.io/otel/trace v1.4.0/go.mod h1:uc3eRsqDfWs9R7b92xbQbU42/eTNz4N+gLP8qJCi4aE= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= -go.temporal.io/api v1.6.1-0.20211110205628-60c98e9cbfe2/go.mod h1:IlUgOTGfmJuOkGrCZdptNxyXKE9CQz6oOx7/aH9bFY4= -go.temporal.io/api v1.7.1-0.20220308002655-96f7fbf5da40 h1:1tmfg5qW4792JnltwiDa35mI5Ccv4Z8X4opbtLDias0= -go.temporal.io/api v1.7.1-0.20220308002655-96f7fbf5da40/go.mod h1:gsMe5hegA/qJoTlSUZ3fZ8dWZw5j0c7DoDeR2PPZOZY= go.temporal.io/sdk v1.13.0 h1:8PW27o/uYAf1C1u8WUd6LNa6He2nYkBhdUX3c5gif5o= go.temporal.io/sdk v1.13.0/go.mod h1:TCof7U/xas2FyDnx/UUEv4c/O/S41Lnhva+6JVer+Jo= go.temporal.io/version v0.3.0 h1:dMrei9l9NyHt8nG6EB8vAwDLLTwx2SvRyucCSumAiig= @@ -593,7 +590,6 @@ golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLd golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211109214657-ef0fda0de508/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211216030914-fe4d6282115f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= @@ -688,7 +684,6 @@ golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20210903071746-97244b99971b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211110154304-99a53858aa08/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -881,7 +876,6 @@ google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEc google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211104193956-4c6863e31247/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= diff --git a/host/signal_workflow_test.go b/host/signal_workflow_test.go index de0abecf9c3..968daeb27ea 100644 --- a/host/signal_workflow_test.go +++ b/host/signal_workflow_test.go @@ -1559,4 +1559,32 @@ func (s *integrationSuite) TestSignalWithStartWorkflow_IDReusePolicy() { resp, err = s.engine.SignalWithStartWorkflowExecution(NewContext(), sRequest) s.NoError(err) s.NotEmpty(resp.GetRunId()) + + // test policy WorkflowIdReusePolicyTerminateIfRunning + prevRunID := resp.RunId + sRequest.WorkflowIdReusePolicy = enumspb.WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING + resp, err = s.engine.SignalWithStartWorkflowExecution(NewContext(), sRequest) + s.NoError(err) + s.NotEmpty(resp.GetRunId()) + s.NotEqual(prevRunID, resp.GetRunId()) + + descResp, err := s.engine.DescribeWorkflowExecution(NewContext(), &workflowservice.DescribeWorkflowExecutionRequest{ + Namespace: s.namespace, + Execution: &commonpb.WorkflowExecution{ + WorkflowId: id, + RunId: prevRunID, + }, + }) + s.NoError(err) + s.Equal(enumspb.WORKFLOW_EXECUTION_STATUS_TERMINATED, descResp.WorkflowExecutionInfo.Status) + + descResp, err = s.engine.DescribeWorkflowExecution(NewContext(), &workflowservice.DescribeWorkflowExecutionRequest{ + Namespace: s.namespace, + Execution: &commonpb.WorkflowExecution{ + WorkflowId: id, + RunId: resp.GetRunId(), + }, + }) + s.NoError(err) + s.Equal(enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, descResp.WorkflowExecutionInfo.Status) } diff --git a/host/workflow_test.go b/host/workflow_test.go index 7207f00d230..a887827c4f7 100644 --- a/host/workflow_test.go +++ b/host/workflow_test.go @@ -105,6 +105,53 @@ func (s *integrationSuite) TestStartWorkflowExecution() { s.Nil(we2) } +func (s *integrationSuite) TestStartWorkflowExecution_TerminateIfRunning() { + id := "integration-start-workflow-terminate-if-running-test" + wt := "integration-start-workflow-terminate-if-running-test-type" + tl := "integration-start-workflow-terminate-if-running-test-taskqueue" + identity := "worker1" + + request := &workflowservice.StartWorkflowExecutionRequest{ + RequestId: uuid.New(), + Namespace: s.namespace, + WorkflowId: id, + WorkflowType: &commonpb.WorkflowType{Name: wt}, + TaskQueue: &taskqueuepb.TaskQueue{Name: tl}, + Input: nil, + WorkflowRunTimeout: timestamp.DurationPtr(100 * time.Second), + Identity: identity, + } + + we0, err0 := s.engine.StartWorkflowExecution(NewContext(), request) + s.NoError(err0) + + request.RequestId = uuid.New() + request.WorkflowIdReusePolicy = enumspb.WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING + we1, err1 := s.engine.StartWorkflowExecution(NewContext(), request) + s.NoError(err1) + s.NotEqual(we0.RunId, we1.RunId) + + descResp, err := s.engine.DescribeWorkflowExecution(NewContext(), &workflowservice.DescribeWorkflowExecutionRequest{ + Namespace: s.namespace, + Execution: &commonpb.WorkflowExecution{ + WorkflowId: id, + RunId: we0.RunId, + }, + }) + s.NoError(err) + s.Equal(enumspb.WORKFLOW_EXECUTION_STATUS_TERMINATED, descResp.WorkflowExecutionInfo.Status) + + descResp, err = s.engine.DescribeWorkflowExecution(NewContext(), &workflowservice.DescribeWorkflowExecutionRequest{ + Namespace: s.namespace, + Execution: &commonpb.WorkflowExecution{ + WorkflowId: id, + RunId: we1.RunId, + }, + }) + s.NoError(err) + s.Equal(enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, descResp.WorkflowExecutionInfo.Status) +} + func (s *integrationSuite) TestTerminateWorkflow() { id := "integration-terminate-workflow-test" wt := "integration-terminate-workflow-test-type" diff --git a/service/history/historyEngine.go b/service/history/historyEngine.go index 0fc114498a5..d690ccef631 100644 --- a/service/history/historyEngine.go +++ b/service/history/historyEngine.go @@ -34,6 +34,7 @@ import ( "github.com/pborman/uuid" commonpb "go.temporal.io/api/common/v1" + "go.temporal.io/api/enums/v1" enumspb "go.temporal.io/api/enums/v1" historypb "go.temporal.io/api/history/v1" querypb "go.temporal.io/api/query/v1" @@ -43,6 +44,7 @@ import ( "go.temporal.io/api/workflowservice/v1" sdkclient "go.temporal.io/sdk/client" + "go.temporal.io/server/common/payloads" "go.temporal.io/server/common/persistence/visibility/manager" "go.temporal.io/server/service/history/queues" "go.temporal.io/server/service/history/tasks" @@ -529,39 +531,12 @@ func (e *historyEngineImpl) StartWorkflowExecution( WorkflowId: workflowID, RunId: uuid.New(), } - clusterMetadata := e.shard.GetClusterMetadata() - mutableState, err := createMutableState(e.shard, namespaceEntry, execution.GetRunId()) - if err != nil { - return nil, err - } - startEvent, err := mutableState.AddWorkflowExecutionStartedEvent( - execution, - startRequest, - ) + weContext, mutableState, err := e.newWorkflowWithSignal(namespaceEntry, execution, startRequest, nil) if err != nil { return nil, err } - // Generate first workflow task event if not child WF and no first workflow task backoff - if err := e.generateFirstWorkflowTask( - mutableState, - startRequest.ParentExecutionInfo, - startEvent, - ); err != nil { - return nil, err - } - - weContext := workflow.NewContext( - e.shard, - definition.NewWorkflowKey( - namespaceID.String(), - execution.GetWorkflowId(), - execution.GetRunId(), - ), - e.logger, - ) - now := e.timeSource.Now() newWorkflow, newWorkflowEventsSeq, err := mutableState.CloseTransactionAsSnapshot( now, @@ -587,57 +562,144 @@ func (e *historyEngineImpl) StartWorkflowExecution( newWorkflow, newWorkflowEventsSeq, ) - if err != nil { - if t, ok := err.(*persistence.CurrentWorkflowConditionFailedError); ok { - if t.RequestID == request.GetRequestId() { - return &historyservice.StartWorkflowExecutionResponse{ - RunId: t.RunID, - }, nil - // delete history is expected here because duplicate start request will create history with different rid - } + if err == nil { + return &historyservice.StartWorkflowExecutionResponse{ + RunId: execution.GetRunId(), + }, nil + } - if mutableState.GetCurrentVersion() < t.LastWriteVersion { - return nil, serviceerror.NewNamespaceNotActive( - request.GetNamespace(), - clusterMetadata.GetCurrentClusterName(), - clusterMetadata.ClusterNameForFailoverVersion(namespaceEntry.IsGlobalNamespace(), t.LastWriteVersion), - ) - } + t, ok := err.(*persistence.CurrentWorkflowConditionFailedError) + if !ok { + return nil, err + } - // create as ID reuse - createMode = persistence.CreateWorkflowModeWorkflowIDReuse - prevRunID = t.RunID - prevLastWriteVersion = t.LastWriteVersion - if err = e.applyWorkflowIDReusePolicyHelper( - t.RequestID, - prevRunID, - t.State, - t.Status, - execution, - startRequest.StartRequest.GetWorkflowIdReusePolicy(), - ); err != nil { - return nil, err - } - err = weContext.CreateWorkflowExecution( - now, - createMode, - prevRunID, - prevLastWriteVersion, - mutableState, - newWorkflow, - newWorkflowEventsSeq, - ) + // handle CurrentWorkflowConditionFailedError + if t.RequestID == request.GetRequestId() { + return &historyservice.StartWorkflowExecutionResponse{ + RunId: t.RunID, + }, nil + // delete history is expected here because duplicate start request will create history with different rid + } + + if mutableState.GetCurrentVersion() < t.LastWriteVersion { + clusterMetadata := e.shard.GetClusterMetadata() + return nil, serviceerror.NewNamespaceNotActive( + request.GetNamespace(), + clusterMetadata.GetCurrentClusterName(), + clusterMetadata.ClusterNameForFailoverVersion(namespaceEntry.IsGlobalNamespace(), t.LastWriteVersion), + ) + } + + // create as ID reuse + prevRunID = t.RunID + prevLastWriteVersion = t.LastWriteVersion + prevExecutionUpdateAction, err := e.applyWorkflowIDReusePolicyHelper( + t.RequestID, + prevRunID, + t.State, + t.Status, + execution, + startRequest.StartRequest.GetWorkflowIdReusePolicy(), + ) + if err != nil { + return nil, err + } + if prevExecutionUpdateAction == nil { + if err = weContext.CreateWorkflowExecution( + now, + persistence.CreateWorkflowModeWorkflowIDReuse, + prevRunID, + prevLastWriteVersion, + mutableState, + newWorkflow, + newWorkflowEventsSeq, + ); err != nil { + return nil, err } + return &historyservice.StartWorkflowExecutionResponse{ + RunId: execution.GetRunId(), + }, nil } + // need to update prev execution and create new execution in one transaction + // create a new mutable state here as the transaction for the one that's already created + // has already been closed. + weContext, mutableState, err = e.newWorkflowWithSignal(namespaceEntry, execution, startRequest, nil) if err != nil { return nil, err } + if err := e.updateWorkflowExecutionWithNew( + ctx, + namespaceID, + commonpb.WorkflowExecution{ + WorkflowId: execution.WorkflowId, + RunId: prevRunID, + }, + prevExecutionUpdateAction, + weContext, + mutableState, + ); err != nil { + return nil, err + } return &historyservice.StartWorkflowExecutionResponse{ RunId: execution.GetRunId(), }, nil } +func (e *historyEngineImpl) newWorkflowWithSignal( + namespaceEntry *namespace.Namespace, + execution commonpb.WorkflowExecution, + startRequest *historyservice.StartWorkflowExecutionRequest, + signalWithStartRequest *workflowservice.SignalWithStartWorkflowExecutionRequest, +) (workflow.Context, workflow.MutableState, error) { + newMutableState, err := createMutableState(e.shard, namespaceEntry, execution.GetRunId()) + if err != nil { + return nil, nil, err + } + + startEvent, err := newMutableState.AddWorkflowExecutionStartedEvent( + execution, + startRequest, + ) + if err != nil { + return nil, nil, err + } + + if signalWithStartRequest != nil { + if signalWithStartRequest.GetRequestId() != "" { + newMutableState.AddSignalRequested(signalWithStartRequest.GetRequestId()) + } + if _, err := newMutableState.AddWorkflowExecutionSignaled( + signalWithStartRequest.GetSignalName(), + signalWithStartRequest.GetSignalInput(), + signalWithStartRequest.GetIdentity(), + signalWithStartRequest.GetHeader(), + ); err != nil { + return nil, nil, err + } + } + + // Generate first workflow task event if not child WF and no first workflow task backoff + if err := e.generateFirstWorkflowTask( + newMutableState, + startRequest.ParentExecutionInfo, + startEvent, + ); err != nil { + return nil, nil, err + } + + newWorkflowContext := workflow.NewContext( + e.shard, + definition.NewWorkflowKey( + namespaceEntry.ID().String(), + execution.GetWorkflowId(), + execution.GetRunId(), + ), + e.logger, + ) + return newWorkflowContext, newMutableState, nil +} + // GetMutableState retrieves the mutable state of the workflow execution func (e *historyEngineImpl) GetMutableState( ctx context.Context, @@ -1951,6 +2013,7 @@ func (e *historyEngineImpl) SignalWithStartWorkflowExecution( WorkflowId: sRequest.WorkflowId, } + var prevContext workflow.Context var prevMutableState workflow.MutableState attempt := 1 @@ -1974,7 +2037,10 @@ func (e *historyEngineImpl) SignalWithStartWorkflowExecution( return nil, err1 } // workflow exist but not running, will restart workflow then signal - if !mutableState.IsWorkflowExecutionRunning() { + // or workflow running but we need to terminate and restart + if !mutableState.IsWorkflowExecutionRunning() || + sRequest.WorkflowIdReusePolicy == enums.WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING { + prevContext = context prevMutableState = mutableState break } @@ -2072,8 +2138,7 @@ func (e *historyEngineImpl) SignalWithStartWorkflowExecution( RunId: uuid.New(), } - clusterMetadata := e.shard.GetClusterMetadata() - mutableState, err := createMutableState(e.shard, namespaceEntry, execution.GetRunId()) + context, mutableState, err := e.newWorkflowWithSignal(namespaceEntry, execution, startRequest, sRequest) if err != nil { return nil, err } @@ -2084,6 +2149,7 @@ func (e *historyEngineImpl) SignalWithStartWorkflowExecution( return nil, err } if prevLastWriteVersion > mutableState.GetCurrentVersion() { + clusterMetadata := e.shard.GetClusterMetadata() return nil, serviceerror.NewNamespaceNotActive( namespace.String(), clusterMetadata.GetCurrentClusterName(), @@ -2091,51 +2157,27 @@ func (e *historyEngineImpl) SignalWithStartWorkflowExecution( ) } - err = e.applyWorkflowIDReusePolicyForSignalWithStart(prevMutableState.GetExecutionState(), execution, request.WorkflowIdReusePolicy) + prevExecutionUpdateAction, err := e.applyWorkflowIDReusePolicyForSignalWithStart(prevMutableState.GetExecutionState(), execution, request.WorkflowIdReusePolicy) if err != nil { return nil, err } - } - - // Add WF start event - startEvent, err := mutableState.AddWorkflowExecutionStartedEvent( - execution, - startRequest, - ) - if err != nil { - return nil, err - } - // Add signal event - if sRequest.GetRequestId() != "" { - mutableState.AddSignalRequested(sRequest.GetRequestId()) - } - if _, err := mutableState.AddWorkflowExecutionSignaled( - sRequest.GetSignalName(), - sRequest.GetSignalInput(), - sRequest.GetIdentity(), - sRequest.GetHeader()); err != nil { - return nil, err - } + if prevExecutionUpdateAction != nil { + if err := e.updateWorkflowWithNewHelper( + newWorkflowContext(prevContext, release, prevMutableState), + prevExecutionUpdateAction, + context, + mutableState, + ); err != nil { + return nil, err + } - if err = e.generateFirstWorkflowTask( - mutableState, - startRequest.ParentExecutionInfo, - startEvent, - ); err != nil { - return nil, err + return &historyservice.SignalWithStartWorkflowExecutionResponse{ + RunId: execution.GetRunId(), + }, nil + } } - context = workflow.NewContext( - e.shard, - definition.NewWorkflowKey( - namespaceID.String(), - execution.GetWorkflowId(), - execution.GetRunId(), - ), - e.logger, - ) - now := e.timeSource.Now() newWorkflow, newWorkflowEventsSeq, err := mutableState.CloseTransactionAsSnapshot( now, @@ -2561,7 +2603,7 @@ func (e *historyEngineImpl) updateWorkflow( } defer func() { workflowContext.getReleaseFn()(retError) }() - return e.updateWorkflowHelper(workflowContext, action) + return e.updateWorkflowWithNewHelper(workflowContext, action, nil, nil) } func (e *historyEngineImpl) updateWorkflowExecution( @@ -2577,12 +2619,37 @@ func (e *historyEngineImpl) updateWorkflowExecution( } defer func() { workflowContext.getReleaseFn()(retError) }() - return e.updateWorkflowHelper(workflowContext, action) + return e.updateWorkflowWithNewHelper(workflowContext, action, nil, nil) } -func (e *historyEngineImpl) updateWorkflowHelper( +func (e *historyEngineImpl) updateWorkflowExecutionWithNew( + ctx context.Context, + namespaceID namespace.ID, + execution commonpb.WorkflowExecution, + action updateWorkflowActionFunc, + newContext workflow.Context, + newMutableState workflow.MutableState, +) (retError error) { + + workflowContext, err := e.loadWorkflowOnce( + ctx, + namespaceID, + execution.GetWorkflowId(), + execution.GetRunId(), + ) + if err != nil { + return err + } + defer func() { workflowContext.getReleaseFn()(retError) }() + + return e.updateWorkflowWithNewHelper(workflowContext, action, newContext, newMutableState) +} + +func (e *historyEngineImpl) updateWorkflowWithNewHelper( workflowContext workflowContext, action updateWorkflowActionFunc, + newContext workflow.Context, + newMutableState workflow.MutableState, ) (retError error) { UpdateHistoryLoop: @@ -2624,7 +2691,18 @@ UpdateHistoryLoop: } } - err = workflowContext.getContext().UpdateWorkflowExecutionAsActive(e.shard.GetTimeSource().Now()) + if newContext != nil || newMutableState != nil { + err = workflowContext.getContext().UpdateWorkflowExecutionWithNewAsActive( + e.shard.GetTimeSource().Now(), + newContext, + newMutableState, + ) + } else { + err = workflowContext.getContext().UpdateWorkflowExecutionAsActive( + e.shard.GetTimeSource().Now(), + ) + } + if err == consts.ErrConflict { if attempt != conditionalRetryCount { _, err = workflowContext.reloadMutableState() @@ -2903,7 +2981,7 @@ func (e *historyEngineImpl) applyWorkflowIDReusePolicyForSignalWithStart( prevExecutionState *persistencespb.WorkflowExecutionState, execution commonpb.WorkflowExecution, wfIDReusePolicy enumspb.WorkflowIdReusePolicy, -) error { +) (updateWorkflowActionFunc, error) { prevStartRequestID := prevExecutionState.CreateRequestId prevRunID := prevExecutionState.RunId @@ -2918,7 +2996,6 @@ func (e *historyEngineImpl) applyWorkflowIDReusePolicyForSignalWithStart( execution, wfIDReusePolicy, ) - } func (e *historyEngineImpl) applyWorkflowIDReusePolicyHelper( @@ -2926,40 +3003,60 @@ func (e *historyEngineImpl) applyWorkflowIDReusePolicyHelper( prevRunID string, prevState enumsspb.WorkflowExecutionState, prevStatus enumspb.WorkflowExecutionStatus, - execution commonpb.WorkflowExecution, + newExecution commonpb.WorkflowExecution, wfIDReusePolicy enumspb.WorkflowIdReusePolicy, -) error { +) (prevExecutionUpdateFn updateWorkflowActionFunc, err error) { // here we know there is some information about the prev workflow, i.e. either running right now // or has history check if the this workflow is finished switch prevState { case enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING: + if wfIDReusePolicy == enumspb.WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING { + return func(context workflow.Context, mutableState workflow.MutableState) (*updateWorkflowAction, error) { + if !mutableState.IsWorkflowExecutionRunning() { + // found workflow already closed after loading, nothing we need to do + return updateWorkflowWithoutWorkflowTask, nil + } + + return updateWorkflowWithoutWorkflowTask, workflow.TerminateWorkflow( + mutableState, + mutableState.GetNextEventID(), + "TerminateIfRunning WorkflowIdReusePolicy Policy", + payloads.EncodeString( + fmt.Sprintf("terminated by new runID: %s", newExecution.RunId), + ), + consts.IdentityHistoryService, + ) + }, nil + } + msg := "Workflow execution is already running. WorkflowId: %v, RunId: %v." - return getWorkflowAlreadyStartedError(msg, prevStartRequestID, execution.GetWorkflowId(), prevRunID) + return nil, getWorkflowAlreadyStartedError(msg, prevStartRequestID, newExecution.GetWorkflowId(), prevRunID) case enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED: // previous workflow completed, proceed default: // persistence.WorkflowStateZombie or unknown type - return serviceerror.NewInternal(fmt.Sprintf("Failed to process workflow, workflow has invalid state: %v.", prevState)) + return nil, serviceerror.NewInternal(fmt.Sprintf("Failed to process workflow, workflow has invalid state: %v.", prevState)) } switch wfIDReusePolicy { case enumspb.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY: if _, ok := consts.FailedWorkflowStatuses[prevStatus]; !ok { msg := "Workflow execution already finished successfully. WorkflowId: %v, RunId: %v. Workflow Id reuse policy: allow duplicate workflow Id if last run failed." - return getWorkflowAlreadyStartedError(msg, prevStartRequestID, execution.GetWorkflowId(), prevRunID) + return nil, getWorkflowAlreadyStartedError(msg, prevStartRequestID, newExecution.GetWorkflowId(), prevRunID) } - case enumspb.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE: + case enumspb.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE, + enumspb.WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING: // as long as workflow not running, so this case has no check case enumspb.WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE: msg := "Workflow execution already finished. WorkflowId: %v, RunId: %v. Workflow Id reuse policy: reject duplicate workflow Id." - return getWorkflowAlreadyStartedError(msg, prevStartRequestID, execution.GetWorkflowId(), prevRunID) + return nil, getWorkflowAlreadyStartedError(msg, prevStartRequestID, newExecution.GetWorkflowId(), prevRunID) default: - return serviceerror.NewInternal(fmt.Sprintf("Failed to process start workflow reuse policy: %v.", wfIDReusePolicy)) + return nil, serviceerror.NewInternal(fmt.Sprintf("Failed to process start workflow reuse policy: %v.", wfIDReusePolicy)) } - return nil + return nil, nil } func getWorkflowAlreadyStartedError(errMsg string, createRequestID string, workflowID string, runID string) error { diff --git a/tools/cli/flags.go b/tools/cli/flags.go index ffe3c747556..a81920be88b 100644 --- a/tools/cli/flags.go +++ b/tools/cli/flags.go @@ -358,7 +358,7 @@ func getFlagsForStart() []cli.Flag { cli.StringFlag{ Name: FlagWorkflowIDReusePolicyAlias, Usage: "Configure if the same workflow Id is allowed for use in new workflow execution. " + - "Options: AllowDuplicate, AllowDuplicateFailedOnly, RejectDuplicate", + "Options: AllowDuplicate, AllowDuplicateFailedOnly, RejectDuplicate, TerminateIfRunning", }, cli.StringSliceFlag{ Name: FlagInputWithAlias, From e053d462151fdfd2af62e89b662614ae3be0d538 Mon Sep 17 00:00:00 2001 From: Yichao Yang Date: Thu, 17 Mar 2022 12:19:09 -0700 Subject: [PATCH 2/4] handle prev execution already closed --- service/history/historyEngine.go | 170 ++++++++++++++++++------------- 1 file changed, 100 insertions(+), 70 deletions(-) diff --git a/service/history/historyEngine.go b/service/history/historyEngine.go index d690ccef631..e804a7f2995 100644 --- a/service/history/historyEngine.go +++ b/service/history/historyEngine.go @@ -581,18 +581,18 @@ func (e *historyEngineImpl) StartWorkflowExecution( // delete history is expected here because duplicate start request will create history with different rid } - if mutableState.GetCurrentVersion() < t.LastWriteVersion { + // create as ID reuse + prevRunID = t.RunID + prevLastWriteVersion = t.LastWriteVersion + if mutableState.GetCurrentVersion() < prevLastWriteVersion { clusterMetadata := e.shard.GetClusterMetadata() return nil, serviceerror.NewNamespaceNotActive( request.GetNamespace(), clusterMetadata.GetCurrentClusterName(), - clusterMetadata.ClusterNameForFailoverVersion(namespaceEntry.IsGlobalNamespace(), t.LastWriteVersion), + clusterMetadata.ClusterNameForFailoverVersion(namespaceEntry.IsGlobalNamespace(), prevLastWriteVersion), ) } - // create as ID reuse - prevRunID = t.RunID - prevLastWriteVersion = t.LastWriteVersion prevExecutionUpdateAction, err := e.applyWorkflowIDReusePolicyHelper( t.RequestID, prevRunID, @@ -604,40 +604,42 @@ func (e *historyEngineImpl) StartWorkflowExecution( if err != nil { return nil, err } - if prevExecutionUpdateAction == nil { - if err = weContext.CreateWorkflowExecution( - now, - persistence.CreateWorkflowModeWorkflowIDReuse, - prevRunID, - prevLastWriteVersion, - mutableState, - newWorkflow, - newWorkflowEventsSeq, - ); err != nil { + + if prevExecutionUpdateAction != nil { + // update prev execution and create new execution in one transaction + err := e.updateWorkflowExecutionWithNew( + ctx, + namespaceID, + commonpb.WorkflowExecution{ + WorkflowId: execution.WorkflowId, + RunId: prevRunID, + }, + prevExecutionUpdateAction, + func() (workflow.Context, workflow.MutableState, error) { + return e.newWorkflowWithSignal(namespaceEntry, execution, startRequest, nil) + }, + ) + switch err { + case nil: + return &historyservice.StartWorkflowExecutionResponse{ + RunId: execution.GetRunId(), + }, nil + case consts.ErrWorkflowCompleted: + // previous workflow already closed + // fallthough to the logic for only creating the new workflow below + default: return nil, err } - return &historyservice.StartWorkflowExecutionResponse{ - RunId: execution.GetRunId(), - }, nil } - // need to update prev execution and create new execution in one transaction - // create a new mutable state here as the transaction for the one that's already created - // has already been closed. - weContext, mutableState, err = e.newWorkflowWithSignal(namespaceEntry, execution, startRequest, nil) - if err != nil { - return nil, err - } - if err := e.updateWorkflowExecutionWithNew( - ctx, - namespaceID, - commonpb.WorkflowExecution{ - WorkflowId: execution.WorkflowId, - RunId: prevRunID, - }, - prevExecutionUpdateAction, - weContext, + if err = weContext.CreateWorkflowExecution( + now, + persistence.CreateWorkflowModeWorkflowIDReuse, + prevRunID, + prevLastWriteVersion, mutableState, + newWorkflow, + newWorkflowEventsSeq, ); err != nil { return nil, err } @@ -2138,47 +2140,44 @@ func (e *historyEngineImpl) SignalWithStartWorkflowExecution( RunId: uuid.New(), } - context, mutableState, err := e.newWorkflowWithSignal(namespaceEntry, execution, startRequest, sRequest) - if err != nil { - return nil, err - } - if prevMutableState != nil { - prevLastWriteVersion, err := prevMutableState.GetLastWriteVersion() - if err != nil { - return nil, err - } - if prevLastWriteVersion > mutableState.GetCurrentVersion() { - clusterMetadata := e.shard.GetClusterMetadata() - return nil, serviceerror.NewNamespaceNotActive( - namespace.String(), - clusterMetadata.GetCurrentClusterName(), - clusterMetadata.ClusterNameForFailoverVersion(namespaceEntry.IsGlobalNamespace(), prevLastWriteVersion), - ) - } - prevExecutionUpdateAction, err := e.applyWorkflowIDReusePolicyForSignalWithStart(prevMutableState.GetExecutionState(), execution, request.WorkflowIdReusePolicy) if err != nil { return nil, err } if prevExecutionUpdateAction != nil { - if err := e.updateWorkflowWithNewHelper( + err := e.updateWorkflowWithNewHelper( newWorkflowContext(prevContext, release, prevMutableState), prevExecutionUpdateAction, - context, - mutableState, - ); err != nil { + func() (workflow.Context, workflow.MutableState, error) { + return e.newWorkflowWithSignal(namespaceEntry, execution, startRequest, sRequest) + }, + ) + switch err { + case nil: + return &historyservice.SignalWithStartWorkflowExecutionResponse{ + RunId: execution.GetRunId(), + }, nil + case consts.ErrWorkflowCompleted: + // previous workflow already closed + // fallthough to the logic for only creating the new workflow below + default: return nil, err } - - return &historyservice.SignalWithStartWorkflowExecutionResponse{ - RunId: execution.GetRunId(), - }, nil } } now := e.timeSource.Now() + context, mutableState, err := e.newWorkflowWithSignal(namespaceEntry, execution, startRequest, sRequest) + if err != nil { + return nil, err + } + + if err := e.newWorkflowVersionCheck(prevMutableState, mutableState); err != nil { + return nil, err + } + newWorkflow, newWorkflowEventsSeq, err := mutableState.CloseTransactionAsSnapshot( now, workflow.TransactionPolicyActive, @@ -2603,7 +2602,7 @@ func (e *historyEngineImpl) updateWorkflow( } defer func() { workflowContext.getReleaseFn()(retError) }() - return e.updateWorkflowWithNewHelper(workflowContext, action, nil, nil) + return e.updateWorkflowWithNewHelper(workflowContext, action, nil) } func (e *historyEngineImpl) updateWorkflowExecution( @@ -2619,7 +2618,7 @@ func (e *historyEngineImpl) updateWorkflowExecution( } defer func() { workflowContext.getReleaseFn()(retError) }() - return e.updateWorkflowWithNewHelper(workflowContext, action, nil, nil) + return e.updateWorkflowWithNewHelper(workflowContext, action, nil) } func (e *historyEngineImpl) updateWorkflowExecutionWithNew( @@ -2627,8 +2626,7 @@ func (e *historyEngineImpl) updateWorkflowExecutionWithNew( namespaceID namespace.ID, execution commonpb.WorkflowExecution, action updateWorkflowActionFunc, - newContext workflow.Context, - newMutableState workflow.MutableState, + newWorkflowFn func() (workflow.Context, workflow.MutableState, error), ) (retError error) { workflowContext, err := e.loadWorkflowOnce( @@ -2642,14 +2640,13 @@ func (e *historyEngineImpl) updateWorkflowExecutionWithNew( } defer func() { workflowContext.getReleaseFn()(retError) }() - return e.updateWorkflowWithNewHelper(workflowContext, action, newContext, newMutableState) + return e.updateWorkflowWithNewHelper(workflowContext, action, newWorkflowFn) } func (e *historyEngineImpl) updateWorkflowWithNewHelper( workflowContext workflowContext, action updateWorkflowActionFunc, - newContext workflow.Context, - newMutableState workflow.MutableState, + newWorkflowFn func() (workflow.Context, workflow.MutableState, error), ) (retError error) { UpdateHistoryLoop: @@ -2691,7 +2688,17 @@ UpdateHistoryLoop: } } - if newContext != nil || newMutableState != nil { + if newWorkflowFn != nil { + var newContext workflow.Context + var newMutableState workflow.MutableState + newContext, newMutableState, err = newWorkflowFn() + if err != nil { + return err + } + if err = e.newWorkflowVersionCheck(mutableState, newMutableState); err != nil { + return err + } + err = workflowContext.getContext().UpdateWorkflowExecutionWithNewAsActive( e.shard.GetTimeSource().Now(), newContext, @@ -2717,6 +2724,30 @@ UpdateHistoryLoop: return consts.ErrMaxAttemptsExceeded } +func (e *historyEngineImpl) newWorkflowVersionCheck( + prevMutableState workflow.MutableState, + newMutableState workflow.MutableState, +) error { + if prevMutableState == nil { + return nil + } + + prevLastWriteVersion, err := prevMutableState.GetLastWriteVersion() + if err != nil { + return err + } + if prevLastWriteVersion > newMutableState.GetCurrentVersion() { + clusterMetadata := e.shard.GetClusterMetadata() + namespaceEntry := newMutableState.GetNamespaceEntry() + return serviceerror.NewNamespaceNotActive( + namespaceEntry.Name().String(), + clusterMetadata.GetCurrentClusterName(), + clusterMetadata.ClusterNameForFailoverVersion(namespaceEntry.IsGlobalNamespace(), prevLastWriteVersion), + ) + } + return nil +} + func (e *historyEngineImpl) failWorkflowTask( context workflow.Context, scheduleID int64, @@ -3015,8 +3046,7 @@ func (e *historyEngineImpl) applyWorkflowIDReusePolicyHelper( if wfIDReusePolicy == enumspb.WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING { return func(context workflow.Context, mutableState workflow.MutableState) (*updateWorkflowAction, error) { if !mutableState.IsWorkflowExecutionRunning() { - // found workflow already closed after loading, nothing we need to do - return updateWorkflowWithoutWorkflowTask, nil + return nil, consts.ErrWorkflowCompleted } return updateWorkflowWithoutWorkflowTask, workflow.TerminateWorkflow( From 9919fc9c11fce736bcbc6fc094e626a8e0f51d07 Mon Sep 17 00:00:00 2001 From: Yichao Yang Date: Mon, 21 Mar 2022 10:56:46 -0700 Subject: [PATCH 3/4] pr comments; update proto --- api/adminservicemock/v1/service.pb.mock.go | 210 +++++------ api/historyservicemock/v1/service.pb.mock.go | 330 +++++++++--------- api/matchingservicemock/v1/service.pb.mock.go | 74 ++-- go.mod | 10 +- go.sum | 18 +- proto/api | 2 +- service/history/historyEngine.go | 5 + 7 files changed, 329 insertions(+), 320 deletions(-) diff --git a/api/adminservicemock/v1/service.pb.mock.go b/api/adminservicemock/v1/service.pb.mock.go index 40a28479b5b..3d162aa2ca2 100644 --- a/api/adminservicemock/v1/service.pb.mock.go +++ b/api/adminservicemock/v1/service.pb.mock.go @@ -33,7 +33,7 @@ import ( reflect "reflect" gomock "github.com/golang/mock/gomock" - adminservice "go.temporal.io/server/api/adminservice/v1" + v1 "go.temporal.io/server/api/adminservice/v1" grpc "google.golang.org/grpc" ) @@ -61,14 +61,14 @@ func (m *MockAdminServiceClient) EXPECT() *MockAdminServiceClientMockRecorder { } // AddOrUpdateRemoteCluster mocks base method. -func (m *MockAdminServiceClient) AddOrUpdateRemoteCluster(ctx context.Context, in *adminservice.AddOrUpdateRemoteClusterRequest, opts ...grpc.CallOption) (*adminservice.AddOrUpdateRemoteClusterResponse, error) { +func (m *MockAdminServiceClient) AddOrUpdateRemoteCluster(ctx context.Context, in *v1.AddOrUpdateRemoteClusterRequest, opts ...grpc.CallOption) (*v1.AddOrUpdateRemoteClusterResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AddOrUpdateRemoteCluster", varargs...) - ret0, _ := ret[0].(*adminservice.AddOrUpdateRemoteClusterResponse) + ret0, _ := ret[0].(*v1.AddOrUpdateRemoteClusterResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -81,14 +81,14 @@ func (mr *MockAdminServiceClientMockRecorder) AddOrUpdateRemoteCluster(ctx, in i } // AddSearchAttributes mocks base method. -func (m *MockAdminServiceClient) AddSearchAttributes(ctx context.Context, in *adminservice.AddSearchAttributesRequest, opts ...grpc.CallOption) (*adminservice.AddSearchAttributesResponse, error) { +func (m *MockAdminServiceClient) AddSearchAttributes(ctx context.Context, in *v1.AddSearchAttributesRequest, opts ...grpc.CallOption) (*v1.AddSearchAttributesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AddSearchAttributes", varargs...) - ret0, _ := ret[0].(*adminservice.AddSearchAttributesResponse) + ret0, _ := ret[0].(*v1.AddSearchAttributesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -101,14 +101,14 @@ func (mr *MockAdminServiceClientMockRecorder) AddSearchAttributes(ctx, in interf } // CloseShard mocks base method. -func (m *MockAdminServiceClient) CloseShard(ctx context.Context, in *adminservice.CloseShardRequest, opts ...grpc.CallOption) (*adminservice.CloseShardResponse, error) { +func (m *MockAdminServiceClient) CloseShard(ctx context.Context, in *v1.CloseShardRequest, opts ...grpc.CallOption) (*v1.CloseShardResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CloseShard", varargs...) - ret0, _ := ret[0].(*adminservice.CloseShardResponse) + ret0, _ := ret[0].(*v1.CloseShardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -121,14 +121,14 @@ func (mr *MockAdminServiceClientMockRecorder) CloseShard(ctx, in interface{}, op } // DescribeCluster mocks base method. -func (m *MockAdminServiceClient) DescribeCluster(ctx context.Context, in *adminservice.DescribeClusterRequest, opts ...grpc.CallOption) (*adminservice.DescribeClusterResponse, error) { +func (m *MockAdminServiceClient) DescribeCluster(ctx context.Context, in *v1.DescribeClusterRequest, opts ...grpc.CallOption) (*v1.DescribeClusterResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeCluster", varargs...) - ret0, _ := ret[0].(*adminservice.DescribeClusterResponse) + ret0, _ := ret[0].(*v1.DescribeClusterResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -141,14 +141,14 @@ func (mr *MockAdminServiceClientMockRecorder) DescribeCluster(ctx, in interface{ } // DescribeHistoryHost mocks base method. -func (m *MockAdminServiceClient) DescribeHistoryHost(ctx context.Context, in *adminservice.DescribeHistoryHostRequest, opts ...grpc.CallOption) (*adminservice.DescribeHistoryHostResponse, error) { +func (m *MockAdminServiceClient) DescribeHistoryHost(ctx context.Context, in *v1.DescribeHistoryHostRequest, opts ...grpc.CallOption) (*v1.DescribeHistoryHostResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeHistoryHost", varargs...) - ret0, _ := ret[0].(*adminservice.DescribeHistoryHostResponse) + ret0, _ := ret[0].(*v1.DescribeHistoryHostResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -161,14 +161,14 @@ func (mr *MockAdminServiceClientMockRecorder) DescribeHistoryHost(ctx, in interf } // DescribeMutableState mocks base method. -func (m *MockAdminServiceClient) DescribeMutableState(ctx context.Context, in *adminservice.DescribeMutableStateRequest, opts ...grpc.CallOption) (*adminservice.DescribeMutableStateResponse, error) { +func (m *MockAdminServiceClient) DescribeMutableState(ctx context.Context, in *v1.DescribeMutableStateRequest, opts ...grpc.CallOption) (*v1.DescribeMutableStateResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeMutableState", varargs...) - ret0, _ := ret[0].(*adminservice.DescribeMutableStateResponse) + ret0, _ := ret[0].(*v1.DescribeMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -181,14 +181,14 @@ func (mr *MockAdminServiceClientMockRecorder) DescribeMutableState(ctx, in inter } // GetDLQMessages mocks base method. -func (m *MockAdminServiceClient) GetDLQMessages(ctx context.Context, in *adminservice.GetDLQMessagesRequest, opts ...grpc.CallOption) (*adminservice.GetDLQMessagesResponse, error) { +func (m *MockAdminServiceClient) GetDLQMessages(ctx context.Context, in *v1.GetDLQMessagesRequest, opts ...grpc.CallOption) (*v1.GetDLQMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetDLQMessages", varargs...) - ret0, _ := ret[0].(*adminservice.GetDLQMessagesResponse) + ret0, _ := ret[0].(*v1.GetDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -201,14 +201,14 @@ func (mr *MockAdminServiceClientMockRecorder) GetDLQMessages(ctx, in interface{} } // GetDLQReplicationMessages mocks base method. -func (m *MockAdminServiceClient) GetDLQReplicationMessages(ctx context.Context, in *adminservice.GetDLQReplicationMessagesRequest, opts ...grpc.CallOption) (*adminservice.GetDLQReplicationMessagesResponse, error) { +func (m *MockAdminServiceClient) GetDLQReplicationMessages(ctx context.Context, in *v1.GetDLQReplicationMessagesRequest, opts ...grpc.CallOption) (*v1.GetDLQReplicationMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetDLQReplicationMessages", varargs...) - ret0, _ := ret[0].(*adminservice.GetDLQReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetDLQReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -221,14 +221,14 @@ func (mr *MockAdminServiceClientMockRecorder) GetDLQReplicationMessages(ctx, in } // GetNamespaceReplicationMessages mocks base method. -func (m *MockAdminServiceClient) GetNamespaceReplicationMessages(ctx context.Context, in *adminservice.GetNamespaceReplicationMessagesRequest, opts ...grpc.CallOption) (*adminservice.GetNamespaceReplicationMessagesResponse, error) { +func (m *MockAdminServiceClient) GetNamespaceReplicationMessages(ctx context.Context, in *v1.GetNamespaceReplicationMessagesRequest, opts ...grpc.CallOption) (*v1.GetNamespaceReplicationMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetNamespaceReplicationMessages", varargs...) - ret0, _ := ret[0].(*adminservice.GetNamespaceReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetNamespaceReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -241,14 +241,14 @@ func (mr *MockAdminServiceClientMockRecorder) GetNamespaceReplicationMessages(ct } // GetReplicationMessages mocks base method. -func (m *MockAdminServiceClient) GetReplicationMessages(ctx context.Context, in *adminservice.GetReplicationMessagesRequest, opts ...grpc.CallOption) (*adminservice.GetReplicationMessagesResponse, error) { +func (m *MockAdminServiceClient) GetReplicationMessages(ctx context.Context, in *v1.GetReplicationMessagesRequest, opts ...grpc.CallOption) (*v1.GetReplicationMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetReplicationMessages", varargs...) - ret0, _ := ret[0].(*adminservice.GetReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -261,14 +261,14 @@ func (mr *MockAdminServiceClientMockRecorder) GetReplicationMessages(ctx, in int } // GetSearchAttributes mocks base method. -func (m *MockAdminServiceClient) GetSearchAttributes(ctx context.Context, in *adminservice.GetSearchAttributesRequest, opts ...grpc.CallOption) (*adminservice.GetSearchAttributesResponse, error) { +func (m *MockAdminServiceClient) GetSearchAttributes(ctx context.Context, in *v1.GetSearchAttributesRequest, opts ...grpc.CallOption) (*v1.GetSearchAttributesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetSearchAttributes", varargs...) - ret0, _ := ret[0].(*adminservice.GetSearchAttributesResponse) + ret0, _ := ret[0].(*v1.GetSearchAttributesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -281,14 +281,14 @@ func (mr *MockAdminServiceClientMockRecorder) GetSearchAttributes(ctx, in interf } // GetShard mocks base method. -func (m *MockAdminServiceClient) GetShard(ctx context.Context, in *adminservice.GetShardRequest, opts ...grpc.CallOption) (*adminservice.GetShardResponse, error) { +func (m *MockAdminServiceClient) GetShard(ctx context.Context, in *v1.GetShardRequest, opts ...grpc.CallOption) (*v1.GetShardResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetShard", varargs...) - ret0, _ := ret[0].(*adminservice.GetShardResponse) + ret0, _ := ret[0].(*v1.GetShardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -301,14 +301,14 @@ func (mr *MockAdminServiceClientMockRecorder) GetShard(ctx, in interface{}, opts } // GetTaskQueueTasks mocks base method. -func (m *MockAdminServiceClient) GetTaskQueueTasks(ctx context.Context, in *adminservice.GetTaskQueueTasksRequest, opts ...grpc.CallOption) (*adminservice.GetTaskQueueTasksResponse, error) { +func (m *MockAdminServiceClient) GetTaskQueueTasks(ctx context.Context, in *v1.GetTaskQueueTasksRequest, opts ...grpc.CallOption) (*v1.GetTaskQueueTasksResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTaskQueueTasks", varargs...) - ret0, _ := ret[0].(*adminservice.GetTaskQueueTasksResponse) + ret0, _ := ret[0].(*v1.GetTaskQueueTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -321,14 +321,14 @@ func (mr *MockAdminServiceClientMockRecorder) GetTaskQueueTasks(ctx, in interfac } // GetWorkflowExecutionRawHistoryV2 mocks base method. -func (m *MockAdminServiceClient) GetWorkflowExecutionRawHistoryV2(ctx context.Context, in *adminservice.GetWorkflowExecutionRawHistoryV2Request, opts ...grpc.CallOption) (*adminservice.GetWorkflowExecutionRawHistoryV2Response, error) { +func (m *MockAdminServiceClient) GetWorkflowExecutionRawHistoryV2(ctx context.Context, in *v1.GetWorkflowExecutionRawHistoryV2Request, opts ...grpc.CallOption) (*v1.GetWorkflowExecutionRawHistoryV2Response, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetWorkflowExecutionRawHistoryV2", varargs...) - ret0, _ := ret[0].(*adminservice.GetWorkflowExecutionRawHistoryV2Response) + ret0, _ := ret[0].(*v1.GetWorkflowExecutionRawHistoryV2Response) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -341,14 +341,14 @@ func (mr *MockAdminServiceClientMockRecorder) GetWorkflowExecutionRawHistoryV2(c } // ListClusterMembers mocks base method. -func (m *MockAdminServiceClient) ListClusterMembers(ctx context.Context, in *adminservice.ListClusterMembersRequest, opts ...grpc.CallOption) (*adminservice.ListClusterMembersResponse, error) { +func (m *MockAdminServiceClient) ListClusterMembers(ctx context.Context, in *v1.ListClusterMembersRequest, opts ...grpc.CallOption) (*v1.ListClusterMembersResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListClusterMembers", varargs...) - ret0, _ := ret[0].(*adminservice.ListClusterMembersResponse) + ret0, _ := ret[0].(*v1.ListClusterMembersResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -361,14 +361,14 @@ func (mr *MockAdminServiceClientMockRecorder) ListClusterMembers(ctx, in interfa } // ListClusters mocks base method. -func (m *MockAdminServiceClient) ListClusters(ctx context.Context, in *adminservice.ListClustersRequest, opts ...grpc.CallOption) (*adminservice.ListClustersResponse, error) { +func (m *MockAdminServiceClient) ListClusters(ctx context.Context, in *v1.ListClustersRequest, opts ...grpc.CallOption) (*v1.ListClustersResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListClusters", varargs...) - ret0, _ := ret[0].(*adminservice.ListClustersResponse) + ret0, _ := ret[0].(*v1.ListClustersResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -381,14 +381,14 @@ func (mr *MockAdminServiceClientMockRecorder) ListClusters(ctx, in interface{}, } // ListHistoryTasks mocks base method. -func (m *MockAdminServiceClient) ListHistoryTasks(ctx context.Context, in *adminservice.ListHistoryTasksRequest, opts ...grpc.CallOption) (*adminservice.ListHistoryTasksResponse, error) { +func (m *MockAdminServiceClient) ListHistoryTasks(ctx context.Context, in *v1.ListHistoryTasksRequest, opts ...grpc.CallOption) (*v1.ListHistoryTasksResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListHistoryTasks", varargs...) - ret0, _ := ret[0].(*adminservice.ListHistoryTasksResponse) + ret0, _ := ret[0].(*v1.ListHistoryTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -401,14 +401,14 @@ func (mr *MockAdminServiceClientMockRecorder) ListHistoryTasks(ctx, in interface } // MergeDLQMessages mocks base method. -func (m *MockAdminServiceClient) MergeDLQMessages(ctx context.Context, in *adminservice.MergeDLQMessagesRequest, opts ...grpc.CallOption) (*adminservice.MergeDLQMessagesResponse, error) { +func (m *MockAdminServiceClient) MergeDLQMessages(ctx context.Context, in *v1.MergeDLQMessagesRequest, opts ...grpc.CallOption) (*v1.MergeDLQMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "MergeDLQMessages", varargs...) - ret0, _ := ret[0].(*adminservice.MergeDLQMessagesResponse) + ret0, _ := ret[0].(*v1.MergeDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -421,14 +421,14 @@ func (mr *MockAdminServiceClientMockRecorder) MergeDLQMessages(ctx, in interface } // PurgeDLQMessages mocks base method. -func (m *MockAdminServiceClient) PurgeDLQMessages(ctx context.Context, in *adminservice.PurgeDLQMessagesRequest, opts ...grpc.CallOption) (*adminservice.PurgeDLQMessagesResponse, error) { +func (m *MockAdminServiceClient) PurgeDLQMessages(ctx context.Context, in *v1.PurgeDLQMessagesRequest, opts ...grpc.CallOption) (*v1.PurgeDLQMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PurgeDLQMessages", varargs...) - ret0, _ := ret[0].(*adminservice.PurgeDLQMessagesResponse) + ret0, _ := ret[0].(*v1.PurgeDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -441,14 +441,14 @@ func (mr *MockAdminServiceClientMockRecorder) PurgeDLQMessages(ctx, in interface } // ReapplyEvents mocks base method. -func (m *MockAdminServiceClient) ReapplyEvents(ctx context.Context, in *adminservice.ReapplyEventsRequest, opts ...grpc.CallOption) (*adminservice.ReapplyEventsResponse, error) { +func (m *MockAdminServiceClient) ReapplyEvents(ctx context.Context, in *v1.ReapplyEventsRequest, opts ...grpc.CallOption) (*v1.ReapplyEventsResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ReapplyEvents", varargs...) - ret0, _ := ret[0].(*adminservice.ReapplyEventsResponse) + ret0, _ := ret[0].(*v1.ReapplyEventsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -461,14 +461,14 @@ func (mr *MockAdminServiceClientMockRecorder) ReapplyEvents(ctx, in interface{}, } // RebuildMutableState mocks base method. -func (m *MockAdminServiceClient) RebuildMutableState(ctx context.Context, in *adminservice.RebuildMutableStateRequest, opts ...grpc.CallOption) (*adminservice.RebuildMutableStateResponse, error) { +func (m *MockAdminServiceClient) RebuildMutableState(ctx context.Context, in *v1.RebuildMutableStateRequest, opts ...grpc.CallOption) (*v1.RebuildMutableStateResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RebuildMutableState", varargs...) - ret0, _ := ret[0].(*adminservice.RebuildMutableStateResponse) + ret0, _ := ret[0].(*v1.RebuildMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -481,14 +481,14 @@ func (mr *MockAdminServiceClientMockRecorder) RebuildMutableState(ctx, in interf } // RefreshWorkflowTasks mocks base method. -func (m *MockAdminServiceClient) RefreshWorkflowTasks(ctx context.Context, in *adminservice.RefreshWorkflowTasksRequest, opts ...grpc.CallOption) (*adminservice.RefreshWorkflowTasksResponse, error) { +func (m *MockAdminServiceClient) RefreshWorkflowTasks(ctx context.Context, in *v1.RefreshWorkflowTasksRequest, opts ...grpc.CallOption) (*v1.RefreshWorkflowTasksResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RefreshWorkflowTasks", varargs...) - ret0, _ := ret[0].(*adminservice.RefreshWorkflowTasksResponse) + ret0, _ := ret[0].(*v1.RefreshWorkflowTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -501,14 +501,14 @@ func (mr *MockAdminServiceClientMockRecorder) RefreshWorkflowTasks(ctx, in inter } // RemoveRemoteCluster mocks base method. -func (m *MockAdminServiceClient) RemoveRemoteCluster(ctx context.Context, in *adminservice.RemoveRemoteClusterRequest, opts ...grpc.CallOption) (*adminservice.RemoveRemoteClusterResponse, error) { +func (m *MockAdminServiceClient) RemoveRemoteCluster(ctx context.Context, in *v1.RemoveRemoteClusterRequest, opts ...grpc.CallOption) (*v1.RemoveRemoteClusterResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RemoveRemoteCluster", varargs...) - ret0, _ := ret[0].(*adminservice.RemoveRemoteClusterResponse) + ret0, _ := ret[0].(*v1.RemoveRemoteClusterResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -521,14 +521,14 @@ func (mr *MockAdminServiceClientMockRecorder) RemoveRemoteCluster(ctx, in interf } // RemoveSearchAttributes mocks base method. -func (m *MockAdminServiceClient) RemoveSearchAttributes(ctx context.Context, in *adminservice.RemoveSearchAttributesRequest, opts ...grpc.CallOption) (*adminservice.RemoveSearchAttributesResponse, error) { +func (m *MockAdminServiceClient) RemoveSearchAttributes(ctx context.Context, in *v1.RemoveSearchAttributesRequest, opts ...grpc.CallOption) (*v1.RemoveSearchAttributesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RemoveSearchAttributes", varargs...) - ret0, _ := ret[0].(*adminservice.RemoveSearchAttributesResponse) + ret0, _ := ret[0].(*v1.RemoveSearchAttributesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -541,14 +541,14 @@ func (mr *MockAdminServiceClientMockRecorder) RemoveSearchAttributes(ctx, in int } // RemoveTask mocks base method. -func (m *MockAdminServiceClient) RemoveTask(ctx context.Context, in *adminservice.RemoveTaskRequest, opts ...grpc.CallOption) (*adminservice.RemoveTaskResponse, error) { +func (m *MockAdminServiceClient) RemoveTask(ctx context.Context, in *v1.RemoveTaskRequest, opts ...grpc.CallOption) (*v1.RemoveTaskResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RemoveTask", varargs...) - ret0, _ := ret[0].(*adminservice.RemoveTaskResponse) + ret0, _ := ret[0].(*v1.RemoveTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -561,14 +561,14 @@ func (mr *MockAdminServiceClientMockRecorder) RemoveTask(ctx, in interface{}, op } // ResendReplicationTasks mocks base method. -func (m *MockAdminServiceClient) ResendReplicationTasks(ctx context.Context, in *adminservice.ResendReplicationTasksRequest, opts ...grpc.CallOption) (*adminservice.ResendReplicationTasksResponse, error) { +func (m *MockAdminServiceClient) ResendReplicationTasks(ctx context.Context, in *v1.ResendReplicationTasksRequest, opts ...grpc.CallOption) (*v1.ResendReplicationTasksResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ResendReplicationTasks", varargs...) - ret0, _ := ret[0].(*adminservice.ResendReplicationTasksResponse) + ret0, _ := ret[0].(*v1.ResendReplicationTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -604,10 +604,10 @@ func (m *MockAdminServiceServer) EXPECT() *MockAdminServiceServerMockRecorder { } // AddOrUpdateRemoteCluster mocks base method. -func (m *MockAdminServiceServer) AddOrUpdateRemoteCluster(arg0 context.Context, arg1 *adminservice.AddOrUpdateRemoteClusterRequest) (*adminservice.AddOrUpdateRemoteClusterResponse, error) { +func (m *MockAdminServiceServer) AddOrUpdateRemoteCluster(arg0 context.Context, arg1 *v1.AddOrUpdateRemoteClusterRequest) (*v1.AddOrUpdateRemoteClusterResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddOrUpdateRemoteCluster", arg0, arg1) - ret0, _ := ret[0].(*adminservice.AddOrUpdateRemoteClusterResponse) + ret0, _ := ret[0].(*v1.AddOrUpdateRemoteClusterResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -619,10 +619,10 @@ func (mr *MockAdminServiceServerMockRecorder) AddOrUpdateRemoteCluster(arg0, arg } // AddSearchAttributes mocks base method. -func (m *MockAdminServiceServer) AddSearchAttributes(arg0 context.Context, arg1 *adminservice.AddSearchAttributesRequest) (*adminservice.AddSearchAttributesResponse, error) { +func (m *MockAdminServiceServer) AddSearchAttributes(arg0 context.Context, arg1 *v1.AddSearchAttributesRequest) (*v1.AddSearchAttributesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddSearchAttributes", arg0, arg1) - ret0, _ := ret[0].(*adminservice.AddSearchAttributesResponse) + ret0, _ := ret[0].(*v1.AddSearchAttributesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -634,10 +634,10 @@ func (mr *MockAdminServiceServerMockRecorder) AddSearchAttributes(arg0, arg1 int } // CloseShard mocks base method. -func (m *MockAdminServiceServer) CloseShard(arg0 context.Context, arg1 *adminservice.CloseShardRequest) (*adminservice.CloseShardResponse, error) { +func (m *MockAdminServiceServer) CloseShard(arg0 context.Context, arg1 *v1.CloseShardRequest) (*v1.CloseShardResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseShard", arg0, arg1) - ret0, _ := ret[0].(*adminservice.CloseShardResponse) + ret0, _ := ret[0].(*v1.CloseShardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -649,10 +649,10 @@ func (mr *MockAdminServiceServerMockRecorder) CloseShard(arg0, arg1 interface{}) } // DescribeCluster mocks base method. -func (m *MockAdminServiceServer) DescribeCluster(arg0 context.Context, arg1 *adminservice.DescribeClusterRequest) (*adminservice.DescribeClusterResponse, error) { +func (m *MockAdminServiceServer) DescribeCluster(arg0 context.Context, arg1 *v1.DescribeClusterRequest) (*v1.DescribeClusterResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeCluster", arg0, arg1) - ret0, _ := ret[0].(*adminservice.DescribeClusterResponse) + ret0, _ := ret[0].(*v1.DescribeClusterResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -664,10 +664,10 @@ func (mr *MockAdminServiceServerMockRecorder) DescribeCluster(arg0, arg1 interfa } // DescribeHistoryHost mocks base method. -func (m *MockAdminServiceServer) DescribeHistoryHost(arg0 context.Context, arg1 *adminservice.DescribeHistoryHostRequest) (*adminservice.DescribeHistoryHostResponse, error) { +func (m *MockAdminServiceServer) DescribeHistoryHost(arg0 context.Context, arg1 *v1.DescribeHistoryHostRequest) (*v1.DescribeHistoryHostResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeHistoryHost", arg0, arg1) - ret0, _ := ret[0].(*adminservice.DescribeHistoryHostResponse) + ret0, _ := ret[0].(*v1.DescribeHistoryHostResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -679,10 +679,10 @@ func (mr *MockAdminServiceServerMockRecorder) DescribeHistoryHost(arg0, arg1 int } // DescribeMutableState mocks base method. -func (m *MockAdminServiceServer) DescribeMutableState(arg0 context.Context, arg1 *adminservice.DescribeMutableStateRequest) (*adminservice.DescribeMutableStateResponse, error) { +func (m *MockAdminServiceServer) DescribeMutableState(arg0 context.Context, arg1 *v1.DescribeMutableStateRequest) (*v1.DescribeMutableStateResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeMutableState", arg0, arg1) - ret0, _ := ret[0].(*adminservice.DescribeMutableStateResponse) + ret0, _ := ret[0].(*v1.DescribeMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -694,10 +694,10 @@ func (mr *MockAdminServiceServerMockRecorder) DescribeMutableState(arg0, arg1 in } // GetDLQMessages mocks base method. -func (m *MockAdminServiceServer) GetDLQMessages(arg0 context.Context, arg1 *adminservice.GetDLQMessagesRequest) (*adminservice.GetDLQMessagesResponse, error) { +func (m *MockAdminServiceServer) GetDLQMessages(arg0 context.Context, arg1 *v1.GetDLQMessagesRequest) (*v1.GetDLQMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetDLQMessages", arg0, arg1) - ret0, _ := ret[0].(*adminservice.GetDLQMessagesResponse) + ret0, _ := ret[0].(*v1.GetDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -709,10 +709,10 @@ func (mr *MockAdminServiceServerMockRecorder) GetDLQMessages(arg0, arg1 interfac } // GetDLQReplicationMessages mocks base method. -func (m *MockAdminServiceServer) GetDLQReplicationMessages(arg0 context.Context, arg1 *adminservice.GetDLQReplicationMessagesRequest) (*adminservice.GetDLQReplicationMessagesResponse, error) { +func (m *MockAdminServiceServer) GetDLQReplicationMessages(arg0 context.Context, arg1 *v1.GetDLQReplicationMessagesRequest) (*v1.GetDLQReplicationMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetDLQReplicationMessages", arg0, arg1) - ret0, _ := ret[0].(*adminservice.GetDLQReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetDLQReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -724,10 +724,10 @@ func (mr *MockAdminServiceServerMockRecorder) GetDLQReplicationMessages(arg0, ar } // GetNamespaceReplicationMessages mocks base method. -func (m *MockAdminServiceServer) GetNamespaceReplicationMessages(arg0 context.Context, arg1 *adminservice.GetNamespaceReplicationMessagesRequest) (*adminservice.GetNamespaceReplicationMessagesResponse, error) { +func (m *MockAdminServiceServer) GetNamespaceReplicationMessages(arg0 context.Context, arg1 *v1.GetNamespaceReplicationMessagesRequest) (*v1.GetNamespaceReplicationMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetNamespaceReplicationMessages", arg0, arg1) - ret0, _ := ret[0].(*adminservice.GetNamespaceReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetNamespaceReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -739,10 +739,10 @@ func (mr *MockAdminServiceServerMockRecorder) GetNamespaceReplicationMessages(ar } // GetReplicationMessages mocks base method. -func (m *MockAdminServiceServer) GetReplicationMessages(arg0 context.Context, arg1 *adminservice.GetReplicationMessagesRequest) (*adminservice.GetReplicationMessagesResponse, error) { +func (m *MockAdminServiceServer) GetReplicationMessages(arg0 context.Context, arg1 *v1.GetReplicationMessagesRequest) (*v1.GetReplicationMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetReplicationMessages", arg0, arg1) - ret0, _ := ret[0].(*adminservice.GetReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -754,10 +754,10 @@ func (mr *MockAdminServiceServerMockRecorder) GetReplicationMessages(arg0, arg1 } // GetSearchAttributes mocks base method. -func (m *MockAdminServiceServer) GetSearchAttributes(arg0 context.Context, arg1 *adminservice.GetSearchAttributesRequest) (*adminservice.GetSearchAttributesResponse, error) { +func (m *MockAdminServiceServer) GetSearchAttributes(arg0 context.Context, arg1 *v1.GetSearchAttributesRequest) (*v1.GetSearchAttributesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetSearchAttributes", arg0, arg1) - ret0, _ := ret[0].(*adminservice.GetSearchAttributesResponse) + ret0, _ := ret[0].(*v1.GetSearchAttributesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -769,10 +769,10 @@ func (mr *MockAdminServiceServerMockRecorder) GetSearchAttributes(arg0, arg1 int } // GetShard mocks base method. -func (m *MockAdminServiceServer) GetShard(arg0 context.Context, arg1 *adminservice.GetShardRequest) (*adminservice.GetShardResponse, error) { +func (m *MockAdminServiceServer) GetShard(arg0 context.Context, arg1 *v1.GetShardRequest) (*v1.GetShardResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetShard", arg0, arg1) - ret0, _ := ret[0].(*adminservice.GetShardResponse) + ret0, _ := ret[0].(*v1.GetShardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -784,10 +784,10 @@ func (mr *MockAdminServiceServerMockRecorder) GetShard(arg0, arg1 interface{}) * } // GetTaskQueueTasks mocks base method. -func (m *MockAdminServiceServer) GetTaskQueueTasks(arg0 context.Context, arg1 *adminservice.GetTaskQueueTasksRequest) (*adminservice.GetTaskQueueTasksResponse, error) { +func (m *MockAdminServiceServer) GetTaskQueueTasks(arg0 context.Context, arg1 *v1.GetTaskQueueTasksRequest) (*v1.GetTaskQueueTasksResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTaskQueueTasks", arg0, arg1) - ret0, _ := ret[0].(*adminservice.GetTaskQueueTasksResponse) + ret0, _ := ret[0].(*v1.GetTaskQueueTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -799,10 +799,10 @@ func (mr *MockAdminServiceServerMockRecorder) GetTaskQueueTasks(arg0, arg1 inter } // GetWorkflowExecutionRawHistoryV2 mocks base method. -func (m *MockAdminServiceServer) GetWorkflowExecutionRawHistoryV2(arg0 context.Context, arg1 *adminservice.GetWorkflowExecutionRawHistoryV2Request) (*adminservice.GetWorkflowExecutionRawHistoryV2Response, error) { +func (m *MockAdminServiceServer) GetWorkflowExecutionRawHistoryV2(arg0 context.Context, arg1 *v1.GetWorkflowExecutionRawHistoryV2Request) (*v1.GetWorkflowExecutionRawHistoryV2Response, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetWorkflowExecutionRawHistoryV2", arg0, arg1) - ret0, _ := ret[0].(*adminservice.GetWorkflowExecutionRawHistoryV2Response) + ret0, _ := ret[0].(*v1.GetWorkflowExecutionRawHistoryV2Response) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -814,10 +814,10 @@ func (mr *MockAdminServiceServerMockRecorder) GetWorkflowExecutionRawHistoryV2(a } // ListClusterMembers mocks base method. -func (m *MockAdminServiceServer) ListClusterMembers(arg0 context.Context, arg1 *adminservice.ListClusterMembersRequest) (*adminservice.ListClusterMembersResponse, error) { +func (m *MockAdminServiceServer) ListClusterMembers(arg0 context.Context, arg1 *v1.ListClusterMembersRequest) (*v1.ListClusterMembersResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListClusterMembers", arg0, arg1) - ret0, _ := ret[0].(*adminservice.ListClusterMembersResponse) + ret0, _ := ret[0].(*v1.ListClusterMembersResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -829,10 +829,10 @@ func (mr *MockAdminServiceServerMockRecorder) ListClusterMembers(arg0, arg1 inte } // ListClusters mocks base method. -func (m *MockAdminServiceServer) ListClusters(arg0 context.Context, arg1 *adminservice.ListClustersRequest) (*adminservice.ListClustersResponse, error) { +func (m *MockAdminServiceServer) ListClusters(arg0 context.Context, arg1 *v1.ListClustersRequest) (*v1.ListClustersResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListClusters", arg0, arg1) - ret0, _ := ret[0].(*adminservice.ListClustersResponse) + ret0, _ := ret[0].(*v1.ListClustersResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -844,10 +844,10 @@ func (mr *MockAdminServiceServerMockRecorder) ListClusters(arg0, arg1 interface{ } // ListHistoryTasks mocks base method. -func (m *MockAdminServiceServer) ListHistoryTasks(arg0 context.Context, arg1 *adminservice.ListHistoryTasksRequest) (*adminservice.ListHistoryTasksResponse, error) { +func (m *MockAdminServiceServer) ListHistoryTasks(arg0 context.Context, arg1 *v1.ListHistoryTasksRequest) (*v1.ListHistoryTasksResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHistoryTasks", arg0, arg1) - ret0, _ := ret[0].(*adminservice.ListHistoryTasksResponse) + ret0, _ := ret[0].(*v1.ListHistoryTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -859,10 +859,10 @@ func (mr *MockAdminServiceServerMockRecorder) ListHistoryTasks(arg0, arg1 interf } // MergeDLQMessages mocks base method. -func (m *MockAdminServiceServer) MergeDLQMessages(arg0 context.Context, arg1 *adminservice.MergeDLQMessagesRequest) (*adminservice.MergeDLQMessagesResponse, error) { +func (m *MockAdminServiceServer) MergeDLQMessages(arg0 context.Context, arg1 *v1.MergeDLQMessagesRequest) (*v1.MergeDLQMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MergeDLQMessages", arg0, arg1) - ret0, _ := ret[0].(*adminservice.MergeDLQMessagesResponse) + ret0, _ := ret[0].(*v1.MergeDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -874,10 +874,10 @@ func (mr *MockAdminServiceServerMockRecorder) MergeDLQMessages(arg0, arg1 interf } // PurgeDLQMessages mocks base method. -func (m *MockAdminServiceServer) PurgeDLQMessages(arg0 context.Context, arg1 *adminservice.PurgeDLQMessagesRequest) (*adminservice.PurgeDLQMessagesResponse, error) { +func (m *MockAdminServiceServer) PurgeDLQMessages(arg0 context.Context, arg1 *v1.PurgeDLQMessagesRequest) (*v1.PurgeDLQMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PurgeDLQMessages", arg0, arg1) - ret0, _ := ret[0].(*adminservice.PurgeDLQMessagesResponse) + ret0, _ := ret[0].(*v1.PurgeDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -889,10 +889,10 @@ func (mr *MockAdminServiceServerMockRecorder) PurgeDLQMessages(arg0, arg1 interf } // ReapplyEvents mocks base method. -func (m *MockAdminServiceServer) ReapplyEvents(arg0 context.Context, arg1 *adminservice.ReapplyEventsRequest) (*adminservice.ReapplyEventsResponse, error) { +func (m *MockAdminServiceServer) ReapplyEvents(arg0 context.Context, arg1 *v1.ReapplyEventsRequest) (*v1.ReapplyEventsResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReapplyEvents", arg0, arg1) - ret0, _ := ret[0].(*adminservice.ReapplyEventsResponse) + ret0, _ := ret[0].(*v1.ReapplyEventsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -904,10 +904,10 @@ func (mr *MockAdminServiceServerMockRecorder) ReapplyEvents(arg0, arg1 interface } // RebuildMutableState mocks base method. -func (m *MockAdminServiceServer) RebuildMutableState(arg0 context.Context, arg1 *adminservice.RebuildMutableStateRequest) (*adminservice.RebuildMutableStateResponse, error) { +func (m *MockAdminServiceServer) RebuildMutableState(arg0 context.Context, arg1 *v1.RebuildMutableStateRequest) (*v1.RebuildMutableStateResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RebuildMutableState", arg0, arg1) - ret0, _ := ret[0].(*adminservice.RebuildMutableStateResponse) + ret0, _ := ret[0].(*v1.RebuildMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -919,10 +919,10 @@ func (mr *MockAdminServiceServerMockRecorder) RebuildMutableState(arg0, arg1 int } // RefreshWorkflowTasks mocks base method. -func (m *MockAdminServiceServer) RefreshWorkflowTasks(arg0 context.Context, arg1 *adminservice.RefreshWorkflowTasksRequest) (*adminservice.RefreshWorkflowTasksResponse, error) { +func (m *MockAdminServiceServer) RefreshWorkflowTasks(arg0 context.Context, arg1 *v1.RefreshWorkflowTasksRequest) (*v1.RefreshWorkflowTasksResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RefreshWorkflowTasks", arg0, arg1) - ret0, _ := ret[0].(*adminservice.RefreshWorkflowTasksResponse) + ret0, _ := ret[0].(*v1.RefreshWorkflowTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -934,10 +934,10 @@ func (mr *MockAdminServiceServerMockRecorder) RefreshWorkflowTasks(arg0, arg1 in } // RemoveRemoteCluster mocks base method. -func (m *MockAdminServiceServer) RemoveRemoteCluster(arg0 context.Context, arg1 *adminservice.RemoveRemoteClusterRequest) (*adminservice.RemoveRemoteClusterResponse, error) { +func (m *MockAdminServiceServer) RemoveRemoteCluster(arg0 context.Context, arg1 *v1.RemoveRemoteClusterRequest) (*v1.RemoveRemoteClusterResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveRemoteCluster", arg0, arg1) - ret0, _ := ret[0].(*adminservice.RemoveRemoteClusterResponse) + ret0, _ := ret[0].(*v1.RemoveRemoteClusterResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -949,10 +949,10 @@ func (mr *MockAdminServiceServerMockRecorder) RemoveRemoteCluster(arg0, arg1 int } // RemoveSearchAttributes mocks base method. -func (m *MockAdminServiceServer) RemoveSearchAttributes(arg0 context.Context, arg1 *adminservice.RemoveSearchAttributesRequest) (*adminservice.RemoveSearchAttributesResponse, error) { +func (m *MockAdminServiceServer) RemoveSearchAttributes(arg0 context.Context, arg1 *v1.RemoveSearchAttributesRequest) (*v1.RemoveSearchAttributesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveSearchAttributes", arg0, arg1) - ret0, _ := ret[0].(*adminservice.RemoveSearchAttributesResponse) + ret0, _ := ret[0].(*v1.RemoveSearchAttributesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -964,10 +964,10 @@ func (mr *MockAdminServiceServerMockRecorder) RemoveSearchAttributes(arg0, arg1 } // RemoveTask mocks base method. -func (m *MockAdminServiceServer) RemoveTask(arg0 context.Context, arg1 *adminservice.RemoveTaskRequest) (*adminservice.RemoveTaskResponse, error) { +func (m *MockAdminServiceServer) RemoveTask(arg0 context.Context, arg1 *v1.RemoveTaskRequest) (*v1.RemoveTaskResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTask", arg0, arg1) - ret0, _ := ret[0].(*adminservice.RemoveTaskResponse) + ret0, _ := ret[0].(*v1.RemoveTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -979,10 +979,10 @@ func (mr *MockAdminServiceServerMockRecorder) RemoveTask(arg0, arg1 interface{}) } // ResendReplicationTasks mocks base method. -func (m *MockAdminServiceServer) ResendReplicationTasks(arg0 context.Context, arg1 *adminservice.ResendReplicationTasksRequest) (*adminservice.ResendReplicationTasksResponse, error) { +func (m *MockAdminServiceServer) ResendReplicationTasks(arg0 context.Context, arg1 *v1.ResendReplicationTasksRequest) (*v1.ResendReplicationTasksResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ResendReplicationTasks", arg0, arg1) - ret0, _ := ret[0].(*adminservice.ResendReplicationTasksResponse) + ret0, _ := ret[0].(*v1.ResendReplicationTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } diff --git a/api/historyservicemock/v1/service.pb.mock.go b/api/historyservicemock/v1/service.pb.mock.go index 62ce0d33f3e..b9589c73e6a 100644 --- a/api/historyservicemock/v1/service.pb.mock.go +++ b/api/historyservicemock/v1/service.pb.mock.go @@ -33,7 +33,7 @@ import ( reflect "reflect" gomock "github.com/golang/mock/gomock" - historyservice "go.temporal.io/server/api/historyservice/v1" + v1 "go.temporal.io/server/api/historyservice/v1" grpc "google.golang.org/grpc" ) @@ -61,14 +61,14 @@ func (m *MockHistoryServiceClient) EXPECT() *MockHistoryServiceClientMockRecorde } // CloseShard mocks base method. -func (m *MockHistoryServiceClient) CloseShard(ctx context.Context, in *historyservice.CloseShardRequest, opts ...grpc.CallOption) (*historyservice.CloseShardResponse, error) { +func (m *MockHistoryServiceClient) CloseShard(ctx context.Context, in *v1.CloseShardRequest, opts ...grpc.CallOption) (*v1.CloseShardResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CloseShard", varargs...) - ret0, _ := ret[0].(*historyservice.CloseShardResponse) + ret0, _ := ret[0].(*v1.CloseShardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -81,14 +81,14 @@ func (mr *MockHistoryServiceClientMockRecorder) CloseShard(ctx, in interface{}, } // DeleteWorkflowExecution mocks base method. -func (m *MockHistoryServiceClient) DeleteWorkflowExecution(ctx context.Context, in *historyservice.DeleteWorkflowExecutionRequest, opts ...grpc.CallOption) (*historyservice.DeleteWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceClient) DeleteWorkflowExecution(ctx context.Context, in *v1.DeleteWorkflowExecutionRequest, opts ...grpc.CallOption) (*v1.DeleteWorkflowExecutionResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteWorkflowExecution", varargs...) - ret0, _ := ret[0].(*historyservice.DeleteWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.DeleteWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -101,14 +101,14 @@ func (mr *MockHistoryServiceClientMockRecorder) DeleteWorkflowExecution(ctx, in } // DescribeHistoryHost mocks base method. -func (m *MockHistoryServiceClient) DescribeHistoryHost(ctx context.Context, in *historyservice.DescribeHistoryHostRequest, opts ...grpc.CallOption) (*historyservice.DescribeHistoryHostResponse, error) { +func (m *MockHistoryServiceClient) DescribeHistoryHost(ctx context.Context, in *v1.DescribeHistoryHostRequest, opts ...grpc.CallOption) (*v1.DescribeHistoryHostResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeHistoryHost", varargs...) - ret0, _ := ret[0].(*historyservice.DescribeHistoryHostResponse) + ret0, _ := ret[0].(*v1.DescribeHistoryHostResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -121,14 +121,14 @@ func (mr *MockHistoryServiceClientMockRecorder) DescribeHistoryHost(ctx, in inte } // DescribeMutableState mocks base method. -func (m *MockHistoryServiceClient) DescribeMutableState(ctx context.Context, in *historyservice.DescribeMutableStateRequest, opts ...grpc.CallOption) (*historyservice.DescribeMutableStateResponse, error) { +func (m *MockHistoryServiceClient) DescribeMutableState(ctx context.Context, in *v1.DescribeMutableStateRequest, opts ...grpc.CallOption) (*v1.DescribeMutableStateResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeMutableState", varargs...) - ret0, _ := ret[0].(*historyservice.DescribeMutableStateResponse) + ret0, _ := ret[0].(*v1.DescribeMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -141,14 +141,14 @@ func (mr *MockHistoryServiceClientMockRecorder) DescribeMutableState(ctx, in int } // DescribeWorkflowExecution mocks base method. -func (m *MockHistoryServiceClient) DescribeWorkflowExecution(ctx context.Context, in *historyservice.DescribeWorkflowExecutionRequest, opts ...grpc.CallOption) (*historyservice.DescribeWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceClient) DescribeWorkflowExecution(ctx context.Context, in *v1.DescribeWorkflowExecutionRequest, opts ...grpc.CallOption) (*v1.DescribeWorkflowExecutionResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeWorkflowExecution", varargs...) - ret0, _ := ret[0].(*historyservice.DescribeWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.DescribeWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -161,14 +161,14 @@ func (mr *MockHistoryServiceClientMockRecorder) DescribeWorkflowExecution(ctx, i } // GenerateLastHistoryReplicationTasks mocks base method. -func (m *MockHistoryServiceClient) GenerateLastHistoryReplicationTasks(ctx context.Context, in *historyservice.GenerateLastHistoryReplicationTasksRequest, opts ...grpc.CallOption) (*historyservice.GenerateLastHistoryReplicationTasksResponse, error) { +func (m *MockHistoryServiceClient) GenerateLastHistoryReplicationTasks(ctx context.Context, in *v1.GenerateLastHistoryReplicationTasksRequest, opts ...grpc.CallOption) (*v1.GenerateLastHistoryReplicationTasksResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GenerateLastHistoryReplicationTasks", varargs...) - ret0, _ := ret[0].(*historyservice.GenerateLastHistoryReplicationTasksResponse) + ret0, _ := ret[0].(*v1.GenerateLastHistoryReplicationTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -181,14 +181,14 @@ func (mr *MockHistoryServiceClientMockRecorder) GenerateLastHistoryReplicationTa } // GetDLQMessages mocks base method. -func (m *MockHistoryServiceClient) GetDLQMessages(ctx context.Context, in *historyservice.GetDLQMessagesRequest, opts ...grpc.CallOption) (*historyservice.GetDLQMessagesResponse, error) { +func (m *MockHistoryServiceClient) GetDLQMessages(ctx context.Context, in *v1.GetDLQMessagesRequest, opts ...grpc.CallOption) (*v1.GetDLQMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetDLQMessages", varargs...) - ret0, _ := ret[0].(*historyservice.GetDLQMessagesResponse) + ret0, _ := ret[0].(*v1.GetDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -201,14 +201,14 @@ func (mr *MockHistoryServiceClientMockRecorder) GetDLQMessages(ctx, in interface } // GetDLQReplicationMessages mocks base method. -func (m *MockHistoryServiceClient) GetDLQReplicationMessages(ctx context.Context, in *historyservice.GetDLQReplicationMessagesRequest, opts ...grpc.CallOption) (*historyservice.GetDLQReplicationMessagesResponse, error) { +func (m *MockHistoryServiceClient) GetDLQReplicationMessages(ctx context.Context, in *v1.GetDLQReplicationMessagesRequest, opts ...grpc.CallOption) (*v1.GetDLQReplicationMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetDLQReplicationMessages", varargs...) - ret0, _ := ret[0].(*historyservice.GetDLQReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetDLQReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -221,14 +221,14 @@ func (mr *MockHistoryServiceClientMockRecorder) GetDLQReplicationMessages(ctx, i } // GetMutableState mocks base method. -func (m *MockHistoryServiceClient) GetMutableState(ctx context.Context, in *historyservice.GetMutableStateRequest, opts ...grpc.CallOption) (*historyservice.GetMutableStateResponse, error) { +func (m *MockHistoryServiceClient) GetMutableState(ctx context.Context, in *v1.GetMutableStateRequest, opts ...grpc.CallOption) (*v1.GetMutableStateResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetMutableState", varargs...) - ret0, _ := ret[0].(*historyservice.GetMutableStateResponse) + ret0, _ := ret[0].(*v1.GetMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -241,14 +241,14 @@ func (mr *MockHistoryServiceClientMockRecorder) GetMutableState(ctx, in interfac } // GetReplicationMessages mocks base method. -func (m *MockHistoryServiceClient) GetReplicationMessages(ctx context.Context, in *historyservice.GetReplicationMessagesRequest, opts ...grpc.CallOption) (*historyservice.GetReplicationMessagesResponse, error) { +func (m *MockHistoryServiceClient) GetReplicationMessages(ctx context.Context, in *v1.GetReplicationMessagesRequest, opts ...grpc.CallOption) (*v1.GetReplicationMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetReplicationMessages", varargs...) - ret0, _ := ret[0].(*historyservice.GetReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -261,14 +261,14 @@ func (mr *MockHistoryServiceClientMockRecorder) GetReplicationMessages(ctx, in i } // GetReplicationStatus mocks base method. -func (m *MockHistoryServiceClient) GetReplicationStatus(ctx context.Context, in *historyservice.GetReplicationStatusRequest, opts ...grpc.CallOption) (*historyservice.GetReplicationStatusResponse, error) { +func (m *MockHistoryServiceClient) GetReplicationStatus(ctx context.Context, in *v1.GetReplicationStatusRequest, opts ...grpc.CallOption) (*v1.GetReplicationStatusResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetReplicationStatus", varargs...) - ret0, _ := ret[0].(*historyservice.GetReplicationStatusResponse) + ret0, _ := ret[0].(*v1.GetReplicationStatusResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -281,14 +281,14 @@ func (mr *MockHistoryServiceClientMockRecorder) GetReplicationStatus(ctx, in int } // GetShard mocks base method. -func (m *MockHistoryServiceClient) GetShard(ctx context.Context, in *historyservice.GetShardRequest, opts ...grpc.CallOption) (*historyservice.GetShardResponse, error) { +func (m *MockHistoryServiceClient) GetShard(ctx context.Context, in *v1.GetShardRequest, opts ...grpc.CallOption) (*v1.GetShardResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetShard", varargs...) - ret0, _ := ret[0].(*historyservice.GetShardResponse) + ret0, _ := ret[0].(*v1.GetShardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -301,14 +301,14 @@ func (mr *MockHistoryServiceClientMockRecorder) GetShard(ctx, in interface{}, op } // MergeDLQMessages mocks base method. -func (m *MockHistoryServiceClient) MergeDLQMessages(ctx context.Context, in *historyservice.MergeDLQMessagesRequest, opts ...grpc.CallOption) (*historyservice.MergeDLQMessagesResponse, error) { +func (m *MockHistoryServiceClient) MergeDLQMessages(ctx context.Context, in *v1.MergeDLQMessagesRequest, opts ...grpc.CallOption) (*v1.MergeDLQMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "MergeDLQMessages", varargs...) - ret0, _ := ret[0].(*historyservice.MergeDLQMessagesResponse) + ret0, _ := ret[0].(*v1.MergeDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -321,14 +321,14 @@ func (mr *MockHistoryServiceClientMockRecorder) MergeDLQMessages(ctx, in interfa } // PollMutableState mocks base method. -func (m *MockHistoryServiceClient) PollMutableState(ctx context.Context, in *historyservice.PollMutableStateRequest, opts ...grpc.CallOption) (*historyservice.PollMutableStateResponse, error) { +func (m *MockHistoryServiceClient) PollMutableState(ctx context.Context, in *v1.PollMutableStateRequest, opts ...grpc.CallOption) (*v1.PollMutableStateResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PollMutableState", varargs...) - ret0, _ := ret[0].(*historyservice.PollMutableStateResponse) + ret0, _ := ret[0].(*v1.PollMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -341,14 +341,14 @@ func (mr *MockHistoryServiceClientMockRecorder) PollMutableState(ctx, in interfa } // PurgeDLQMessages mocks base method. -func (m *MockHistoryServiceClient) PurgeDLQMessages(ctx context.Context, in *historyservice.PurgeDLQMessagesRequest, opts ...grpc.CallOption) (*historyservice.PurgeDLQMessagesResponse, error) { +func (m *MockHistoryServiceClient) PurgeDLQMessages(ctx context.Context, in *v1.PurgeDLQMessagesRequest, opts ...grpc.CallOption) (*v1.PurgeDLQMessagesResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PurgeDLQMessages", varargs...) - ret0, _ := ret[0].(*historyservice.PurgeDLQMessagesResponse) + ret0, _ := ret[0].(*v1.PurgeDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -361,14 +361,14 @@ func (mr *MockHistoryServiceClientMockRecorder) PurgeDLQMessages(ctx, in interfa } // QueryWorkflow mocks base method. -func (m *MockHistoryServiceClient) QueryWorkflow(ctx context.Context, in *historyservice.QueryWorkflowRequest, opts ...grpc.CallOption) (*historyservice.QueryWorkflowResponse, error) { +func (m *MockHistoryServiceClient) QueryWorkflow(ctx context.Context, in *v1.QueryWorkflowRequest, opts ...grpc.CallOption) (*v1.QueryWorkflowResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "QueryWorkflow", varargs...) - ret0, _ := ret[0].(*historyservice.QueryWorkflowResponse) + ret0, _ := ret[0].(*v1.QueryWorkflowResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -381,14 +381,14 @@ func (mr *MockHistoryServiceClientMockRecorder) QueryWorkflow(ctx, in interface{ } // ReapplyEvents mocks base method. -func (m *MockHistoryServiceClient) ReapplyEvents(ctx context.Context, in *historyservice.ReapplyEventsRequest, opts ...grpc.CallOption) (*historyservice.ReapplyEventsResponse, error) { +func (m *MockHistoryServiceClient) ReapplyEvents(ctx context.Context, in *v1.ReapplyEventsRequest, opts ...grpc.CallOption) (*v1.ReapplyEventsResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ReapplyEvents", varargs...) - ret0, _ := ret[0].(*historyservice.ReapplyEventsResponse) + ret0, _ := ret[0].(*v1.ReapplyEventsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -401,14 +401,14 @@ func (mr *MockHistoryServiceClientMockRecorder) ReapplyEvents(ctx, in interface{ } // RebuildMutableState mocks base method. -func (m *MockHistoryServiceClient) RebuildMutableState(ctx context.Context, in *historyservice.RebuildMutableStateRequest, opts ...grpc.CallOption) (*historyservice.RebuildMutableStateResponse, error) { +func (m *MockHistoryServiceClient) RebuildMutableState(ctx context.Context, in *v1.RebuildMutableStateRequest, opts ...grpc.CallOption) (*v1.RebuildMutableStateResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RebuildMutableState", varargs...) - ret0, _ := ret[0].(*historyservice.RebuildMutableStateResponse) + ret0, _ := ret[0].(*v1.RebuildMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -421,14 +421,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RebuildMutableState(ctx, in inte } // RecordActivityTaskHeartbeat mocks base method. -func (m *MockHistoryServiceClient) RecordActivityTaskHeartbeat(ctx context.Context, in *historyservice.RecordActivityTaskHeartbeatRequest, opts ...grpc.CallOption) (*historyservice.RecordActivityTaskHeartbeatResponse, error) { +func (m *MockHistoryServiceClient) RecordActivityTaskHeartbeat(ctx context.Context, in *v1.RecordActivityTaskHeartbeatRequest, opts ...grpc.CallOption) (*v1.RecordActivityTaskHeartbeatResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RecordActivityTaskHeartbeat", varargs...) - ret0, _ := ret[0].(*historyservice.RecordActivityTaskHeartbeatResponse) + ret0, _ := ret[0].(*v1.RecordActivityTaskHeartbeatResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -441,14 +441,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RecordActivityTaskHeartbeat(ctx, } // RecordActivityTaskStarted mocks base method. -func (m *MockHistoryServiceClient) RecordActivityTaskStarted(ctx context.Context, in *historyservice.RecordActivityTaskStartedRequest, opts ...grpc.CallOption) (*historyservice.RecordActivityTaskStartedResponse, error) { +func (m *MockHistoryServiceClient) RecordActivityTaskStarted(ctx context.Context, in *v1.RecordActivityTaskStartedRequest, opts ...grpc.CallOption) (*v1.RecordActivityTaskStartedResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RecordActivityTaskStarted", varargs...) - ret0, _ := ret[0].(*historyservice.RecordActivityTaskStartedResponse) + ret0, _ := ret[0].(*v1.RecordActivityTaskStartedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -461,14 +461,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RecordActivityTaskStarted(ctx, i } // RecordChildExecutionCompleted mocks base method. -func (m *MockHistoryServiceClient) RecordChildExecutionCompleted(ctx context.Context, in *historyservice.RecordChildExecutionCompletedRequest, opts ...grpc.CallOption) (*historyservice.RecordChildExecutionCompletedResponse, error) { +func (m *MockHistoryServiceClient) RecordChildExecutionCompleted(ctx context.Context, in *v1.RecordChildExecutionCompletedRequest, opts ...grpc.CallOption) (*v1.RecordChildExecutionCompletedResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RecordChildExecutionCompleted", varargs...) - ret0, _ := ret[0].(*historyservice.RecordChildExecutionCompletedResponse) + ret0, _ := ret[0].(*v1.RecordChildExecutionCompletedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -481,14 +481,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RecordChildExecutionCompleted(ct } // RecordWorkflowTaskStarted mocks base method. -func (m *MockHistoryServiceClient) RecordWorkflowTaskStarted(ctx context.Context, in *historyservice.RecordWorkflowTaskStartedRequest, opts ...grpc.CallOption) (*historyservice.RecordWorkflowTaskStartedResponse, error) { +func (m *MockHistoryServiceClient) RecordWorkflowTaskStarted(ctx context.Context, in *v1.RecordWorkflowTaskStartedRequest, opts ...grpc.CallOption) (*v1.RecordWorkflowTaskStartedResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RecordWorkflowTaskStarted", varargs...) - ret0, _ := ret[0].(*historyservice.RecordWorkflowTaskStartedResponse) + ret0, _ := ret[0].(*v1.RecordWorkflowTaskStartedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -501,14 +501,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RecordWorkflowTaskStarted(ctx, i } // RefreshWorkflowTasks mocks base method. -func (m *MockHistoryServiceClient) RefreshWorkflowTasks(ctx context.Context, in *historyservice.RefreshWorkflowTasksRequest, opts ...grpc.CallOption) (*historyservice.RefreshWorkflowTasksResponse, error) { +func (m *MockHistoryServiceClient) RefreshWorkflowTasks(ctx context.Context, in *v1.RefreshWorkflowTasksRequest, opts ...grpc.CallOption) (*v1.RefreshWorkflowTasksResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RefreshWorkflowTasks", varargs...) - ret0, _ := ret[0].(*historyservice.RefreshWorkflowTasksResponse) + ret0, _ := ret[0].(*v1.RefreshWorkflowTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -521,14 +521,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RefreshWorkflowTasks(ctx, in int } // RemoveSignalMutableState mocks base method. -func (m *MockHistoryServiceClient) RemoveSignalMutableState(ctx context.Context, in *historyservice.RemoveSignalMutableStateRequest, opts ...grpc.CallOption) (*historyservice.RemoveSignalMutableStateResponse, error) { +func (m *MockHistoryServiceClient) RemoveSignalMutableState(ctx context.Context, in *v1.RemoveSignalMutableStateRequest, opts ...grpc.CallOption) (*v1.RemoveSignalMutableStateResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RemoveSignalMutableState", varargs...) - ret0, _ := ret[0].(*historyservice.RemoveSignalMutableStateResponse) + ret0, _ := ret[0].(*v1.RemoveSignalMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -541,14 +541,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RemoveSignalMutableState(ctx, in } // RemoveTask mocks base method. -func (m *MockHistoryServiceClient) RemoveTask(ctx context.Context, in *historyservice.RemoveTaskRequest, opts ...grpc.CallOption) (*historyservice.RemoveTaskResponse, error) { +func (m *MockHistoryServiceClient) RemoveTask(ctx context.Context, in *v1.RemoveTaskRequest, opts ...grpc.CallOption) (*v1.RemoveTaskResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RemoveTask", varargs...) - ret0, _ := ret[0].(*historyservice.RemoveTaskResponse) + ret0, _ := ret[0].(*v1.RemoveTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -561,14 +561,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RemoveTask(ctx, in interface{}, } // ReplicateEventsV2 mocks base method. -func (m *MockHistoryServiceClient) ReplicateEventsV2(ctx context.Context, in *historyservice.ReplicateEventsV2Request, opts ...grpc.CallOption) (*historyservice.ReplicateEventsV2Response, error) { +func (m *MockHistoryServiceClient) ReplicateEventsV2(ctx context.Context, in *v1.ReplicateEventsV2Request, opts ...grpc.CallOption) (*v1.ReplicateEventsV2Response, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ReplicateEventsV2", varargs...) - ret0, _ := ret[0].(*historyservice.ReplicateEventsV2Response) + ret0, _ := ret[0].(*v1.ReplicateEventsV2Response) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -581,14 +581,14 @@ func (mr *MockHistoryServiceClientMockRecorder) ReplicateEventsV2(ctx, in interf } // RequestCancelWorkflowExecution mocks base method. -func (m *MockHistoryServiceClient) RequestCancelWorkflowExecution(ctx context.Context, in *historyservice.RequestCancelWorkflowExecutionRequest, opts ...grpc.CallOption) (*historyservice.RequestCancelWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceClient) RequestCancelWorkflowExecution(ctx context.Context, in *v1.RequestCancelWorkflowExecutionRequest, opts ...grpc.CallOption) (*v1.RequestCancelWorkflowExecutionResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RequestCancelWorkflowExecution", varargs...) - ret0, _ := ret[0].(*historyservice.RequestCancelWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.RequestCancelWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -601,14 +601,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RequestCancelWorkflowExecution(c } // ResetStickyTaskQueue mocks base method. -func (m *MockHistoryServiceClient) ResetStickyTaskQueue(ctx context.Context, in *historyservice.ResetStickyTaskQueueRequest, opts ...grpc.CallOption) (*historyservice.ResetStickyTaskQueueResponse, error) { +func (m *MockHistoryServiceClient) ResetStickyTaskQueue(ctx context.Context, in *v1.ResetStickyTaskQueueRequest, opts ...grpc.CallOption) (*v1.ResetStickyTaskQueueResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ResetStickyTaskQueue", varargs...) - ret0, _ := ret[0].(*historyservice.ResetStickyTaskQueueResponse) + ret0, _ := ret[0].(*v1.ResetStickyTaskQueueResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -621,14 +621,14 @@ func (mr *MockHistoryServiceClientMockRecorder) ResetStickyTaskQueue(ctx, in int } // ResetWorkflowExecution mocks base method. -func (m *MockHistoryServiceClient) ResetWorkflowExecution(ctx context.Context, in *historyservice.ResetWorkflowExecutionRequest, opts ...grpc.CallOption) (*historyservice.ResetWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceClient) ResetWorkflowExecution(ctx context.Context, in *v1.ResetWorkflowExecutionRequest, opts ...grpc.CallOption) (*v1.ResetWorkflowExecutionResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ResetWorkflowExecution", varargs...) - ret0, _ := ret[0].(*historyservice.ResetWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.ResetWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -641,14 +641,14 @@ func (mr *MockHistoryServiceClientMockRecorder) ResetWorkflowExecution(ctx, in i } // RespondActivityTaskCanceled mocks base method. -func (m *MockHistoryServiceClient) RespondActivityTaskCanceled(ctx context.Context, in *historyservice.RespondActivityTaskCanceledRequest, opts ...grpc.CallOption) (*historyservice.RespondActivityTaskCanceledResponse, error) { +func (m *MockHistoryServiceClient) RespondActivityTaskCanceled(ctx context.Context, in *v1.RespondActivityTaskCanceledRequest, opts ...grpc.CallOption) (*v1.RespondActivityTaskCanceledResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RespondActivityTaskCanceled", varargs...) - ret0, _ := ret[0].(*historyservice.RespondActivityTaskCanceledResponse) + ret0, _ := ret[0].(*v1.RespondActivityTaskCanceledResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -661,14 +661,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RespondActivityTaskCanceled(ctx, } // RespondActivityTaskCompleted mocks base method. -func (m *MockHistoryServiceClient) RespondActivityTaskCompleted(ctx context.Context, in *historyservice.RespondActivityTaskCompletedRequest, opts ...grpc.CallOption) (*historyservice.RespondActivityTaskCompletedResponse, error) { +func (m *MockHistoryServiceClient) RespondActivityTaskCompleted(ctx context.Context, in *v1.RespondActivityTaskCompletedRequest, opts ...grpc.CallOption) (*v1.RespondActivityTaskCompletedResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RespondActivityTaskCompleted", varargs...) - ret0, _ := ret[0].(*historyservice.RespondActivityTaskCompletedResponse) + ret0, _ := ret[0].(*v1.RespondActivityTaskCompletedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -681,14 +681,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RespondActivityTaskCompleted(ctx } // RespondActivityTaskFailed mocks base method. -func (m *MockHistoryServiceClient) RespondActivityTaskFailed(ctx context.Context, in *historyservice.RespondActivityTaskFailedRequest, opts ...grpc.CallOption) (*historyservice.RespondActivityTaskFailedResponse, error) { +func (m *MockHistoryServiceClient) RespondActivityTaskFailed(ctx context.Context, in *v1.RespondActivityTaskFailedRequest, opts ...grpc.CallOption) (*v1.RespondActivityTaskFailedResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RespondActivityTaskFailed", varargs...) - ret0, _ := ret[0].(*historyservice.RespondActivityTaskFailedResponse) + ret0, _ := ret[0].(*v1.RespondActivityTaskFailedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -701,14 +701,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RespondActivityTaskFailed(ctx, i } // RespondWorkflowTaskCompleted mocks base method. -func (m *MockHistoryServiceClient) RespondWorkflowTaskCompleted(ctx context.Context, in *historyservice.RespondWorkflowTaskCompletedRequest, opts ...grpc.CallOption) (*historyservice.RespondWorkflowTaskCompletedResponse, error) { +func (m *MockHistoryServiceClient) RespondWorkflowTaskCompleted(ctx context.Context, in *v1.RespondWorkflowTaskCompletedRequest, opts ...grpc.CallOption) (*v1.RespondWorkflowTaskCompletedResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RespondWorkflowTaskCompleted", varargs...) - ret0, _ := ret[0].(*historyservice.RespondWorkflowTaskCompletedResponse) + ret0, _ := ret[0].(*v1.RespondWorkflowTaskCompletedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -721,14 +721,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RespondWorkflowTaskCompleted(ctx } // RespondWorkflowTaskFailed mocks base method. -func (m *MockHistoryServiceClient) RespondWorkflowTaskFailed(ctx context.Context, in *historyservice.RespondWorkflowTaskFailedRequest, opts ...grpc.CallOption) (*historyservice.RespondWorkflowTaskFailedResponse, error) { +func (m *MockHistoryServiceClient) RespondWorkflowTaskFailed(ctx context.Context, in *v1.RespondWorkflowTaskFailedRequest, opts ...grpc.CallOption) (*v1.RespondWorkflowTaskFailedResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RespondWorkflowTaskFailed", varargs...) - ret0, _ := ret[0].(*historyservice.RespondWorkflowTaskFailedResponse) + ret0, _ := ret[0].(*v1.RespondWorkflowTaskFailedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -741,14 +741,14 @@ func (mr *MockHistoryServiceClientMockRecorder) RespondWorkflowTaskFailed(ctx, i } // ScheduleWorkflowTask mocks base method. -func (m *MockHistoryServiceClient) ScheduleWorkflowTask(ctx context.Context, in *historyservice.ScheduleWorkflowTaskRequest, opts ...grpc.CallOption) (*historyservice.ScheduleWorkflowTaskResponse, error) { +func (m *MockHistoryServiceClient) ScheduleWorkflowTask(ctx context.Context, in *v1.ScheduleWorkflowTaskRequest, opts ...grpc.CallOption) (*v1.ScheduleWorkflowTaskResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ScheduleWorkflowTask", varargs...) - ret0, _ := ret[0].(*historyservice.ScheduleWorkflowTaskResponse) + ret0, _ := ret[0].(*v1.ScheduleWorkflowTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -761,14 +761,14 @@ func (mr *MockHistoryServiceClientMockRecorder) ScheduleWorkflowTask(ctx, in int } // SignalWithStartWorkflowExecution mocks base method. -func (m *MockHistoryServiceClient) SignalWithStartWorkflowExecution(ctx context.Context, in *historyservice.SignalWithStartWorkflowExecutionRequest, opts ...grpc.CallOption) (*historyservice.SignalWithStartWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceClient) SignalWithStartWorkflowExecution(ctx context.Context, in *v1.SignalWithStartWorkflowExecutionRequest, opts ...grpc.CallOption) (*v1.SignalWithStartWorkflowExecutionResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SignalWithStartWorkflowExecution", varargs...) - ret0, _ := ret[0].(*historyservice.SignalWithStartWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.SignalWithStartWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -781,14 +781,14 @@ func (mr *MockHistoryServiceClientMockRecorder) SignalWithStartWorkflowExecution } // SignalWorkflowExecution mocks base method. -func (m *MockHistoryServiceClient) SignalWorkflowExecution(ctx context.Context, in *historyservice.SignalWorkflowExecutionRequest, opts ...grpc.CallOption) (*historyservice.SignalWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceClient) SignalWorkflowExecution(ctx context.Context, in *v1.SignalWorkflowExecutionRequest, opts ...grpc.CallOption) (*v1.SignalWorkflowExecutionResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SignalWorkflowExecution", varargs...) - ret0, _ := ret[0].(*historyservice.SignalWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.SignalWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -801,14 +801,14 @@ func (mr *MockHistoryServiceClientMockRecorder) SignalWorkflowExecution(ctx, in } // StartWorkflowExecution mocks base method. -func (m *MockHistoryServiceClient) StartWorkflowExecution(ctx context.Context, in *historyservice.StartWorkflowExecutionRequest, opts ...grpc.CallOption) (*historyservice.StartWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceClient) StartWorkflowExecution(ctx context.Context, in *v1.StartWorkflowExecutionRequest, opts ...grpc.CallOption) (*v1.StartWorkflowExecutionResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "StartWorkflowExecution", varargs...) - ret0, _ := ret[0].(*historyservice.StartWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.StartWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -821,14 +821,14 @@ func (mr *MockHistoryServiceClientMockRecorder) StartWorkflowExecution(ctx, in i } // SyncActivity mocks base method. -func (m *MockHistoryServiceClient) SyncActivity(ctx context.Context, in *historyservice.SyncActivityRequest, opts ...grpc.CallOption) (*historyservice.SyncActivityResponse, error) { +func (m *MockHistoryServiceClient) SyncActivity(ctx context.Context, in *v1.SyncActivityRequest, opts ...grpc.CallOption) (*v1.SyncActivityResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SyncActivity", varargs...) - ret0, _ := ret[0].(*historyservice.SyncActivityResponse) + ret0, _ := ret[0].(*v1.SyncActivityResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -841,14 +841,14 @@ func (mr *MockHistoryServiceClientMockRecorder) SyncActivity(ctx, in interface{} } // SyncShardStatus mocks base method. -func (m *MockHistoryServiceClient) SyncShardStatus(ctx context.Context, in *historyservice.SyncShardStatusRequest, opts ...grpc.CallOption) (*historyservice.SyncShardStatusResponse, error) { +func (m *MockHistoryServiceClient) SyncShardStatus(ctx context.Context, in *v1.SyncShardStatusRequest, opts ...grpc.CallOption) (*v1.SyncShardStatusResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SyncShardStatus", varargs...) - ret0, _ := ret[0].(*historyservice.SyncShardStatusResponse) + ret0, _ := ret[0].(*v1.SyncShardStatusResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -861,14 +861,14 @@ func (mr *MockHistoryServiceClientMockRecorder) SyncShardStatus(ctx, in interfac } // TerminateWorkflowExecution mocks base method. -func (m *MockHistoryServiceClient) TerminateWorkflowExecution(ctx context.Context, in *historyservice.TerminateWorkflowExecutionRequest, opts ...grpc.CallOption) (*historyservice.TerminateWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceClient) TerminateWorkflowExecution(ctx context.Context, in *v1.TerminateWorkflowExecutionRequest, opts ...grpc.CallOption) (*v1.TerminateWorkflowExecutionResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TerminateWorkflowExecution", varargs...) - ret0, _ := ret[0].(*historyservice.TerminateWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.TerminateWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -904,10 +904,10 @@ func (m *MockHistoryServiceServer) EXPECT() *MockHistoryServiceServerMockRecorde } // CloseShard mocks base method. -func (m *MockHistoryServiceServer) CloseShard(arg0 context.Context, arg1 *historyservice.CloseShardRequest) (*historyservice.CloseShardResponse, error) { +func (m *MockHistoryServiceServer) CloseShard(arg0 context.Context, arg1 *v1.CloseShardRequest) (*v1.CloseShardResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseShard", arg0, arg1) - ret0, _ := ret[0].(*historyservice.CloseShardResponse) + ret0, _ := ret[0].(*v1.CloseShardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -919,10 +919,10 @@ func (mr *MockHistoryServiceServerMockRecorder) CloseShard(arg0, arg1 interface{ } // DeleteWorkflowExecution mocks base method. -func (m *MockHistoryServiceServer) DeleteWorkflowExecution(arg0 context.Context, arg1 *historyservice.DeleteWorkflowExecutionRequest) (*historyservice.DeleteWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceServer) DeleteWorkflowExecution(arg0 context.Context, arg1 *v1.DeleteWorkflowExecutionRequest) (*v1.DeleteWorkflowExecutionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteWorkflowExecution", arg0, arg1) - ret0, _ := ret[0].(*historyservice.DeleteWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.DeleteWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -934,10 +934,10 @@ func (mr *MockHistoryServiceServerMockRecorder) DeleteWorkflowExecution(arg0, ar } // DescribeHistoryHost mocks base method. -func (m *MockHistoryServiceServer) DescribeHistoryHost(arg0 context.Context, arg1 *historyservice.DescribeHistoryHostRequest) (*historyservice.DescribeHistoryHostResponse, error) { +func (m *MockHistoryServiceServer) DescribeHistoryHost(arg0 context.Context, arg1 *v1.DescribeHistoryHostRequest) (*v1.DescribeHistoryHostResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeHistoryHost", arg0, arg1) - ret0, _ := ret[0].(*historyservice.DescribeHistoryHostResponse) + ret0, _ := ret[0].(*v1.DescribeHistoryHostResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -949,10 +949,10 @@ func (mr *MockHistoryServiceServerMockRecorder) DescribeHistoryHost(arg0, arg1 i } // DescribeMutableState mocks base method. -func (m *MockHistoryServiceServer) DescribeMutableState(arg0 context.Context, arg1 *historyservice.DescribeMutableStateRequest) (*historyservice.DescribeMutableStateResponse, error) { +func (m *MockHistoryServiceServer) DescribeMutableState(arg0 context.Context, arg1 *v1.DescribeMutableStateRequest) (*v1.DescribeMutableStateResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeMutableState", arg0, arg1) - ret0, _ := ret[0].(*historyservice.DescribeMutableStateResponse) + ret0, _ := ret[0].(*v1.DescribeMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -964,10 +964,10 @@ func (mr *MockHistoryServiceServerMockRecorder) DescribeMutableState(arg0, arg1 } // DescribeWorkflowExecution mocks base method. -func (m *MockHistoryServiceServer) DescribeWorkflowExecution(arg0 context.Context, arg1 *historyservice.DescribeWorkflowExecutionRequest) (*historyservice.DescribeWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceServer) DescribeWorkflowExecution(arg0 context.Context, arg1 *v1.DescribeWorkflowExecutionRequest) (*v1.DescribeWorkflowExecutionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeWorkflowExecution", arg0, arg1) - ret0, _ := ret[0].(*historyservice.DescribeWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.DescribeWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -979,10 +979,10 @@ func (mr *MockHistoryServiceServerMockRecorder) DescribeWorkflowExecution(arg0, } // GenerateLastHistoryReplicationTasks mocks base method. -func (m *MockHistoryServiceServer) GenerateLastHistoryReplicationTasks(arg0 context.Context, arg1 *historyservice.GenerateLastHistoryReplicationTasksRequest) (*historyservice.GenerateLastHistoryReplicationTasksResponse, error) { +func (m *MockHistoryServiceServer) GenerateLastHistoryReplicationTasks(arg0 context.Context, arg1 *v1.GenerateLastHistoryReplicationTasksRequest) (*v1.GenerateLastHistoryReplicationTasksResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GenerateLastHistoryReplicationTasks", arg0, arg1) - ret0, _ := ret[0].(*historyservice.GenerateLastHistoryReplicationTasksResponse) + ret0, _ := ret[0].(*v1.GenerateLastHistoryReplicationTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -994,10 +994,10 @@ func (mr *MockHistoryServiceServerMockRecorder) GenerateLastHistoryReplicationTa } // GetDLQMessages mocks base method. -func (m *MockHistoryServiceServer) GetDLQMessages(arg0 context.Context, arg1 *historyservice.GetDLQMessagesRequest) (*historyservice.GetDLQMessagesResponse, error) { +func (m *MockHistoryServiceServer) GetDLQMessages(arg0 context.Context, arg1 *v1.GetDLQMessagesRequest) (*v1.GetDLQMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetDLQMessages", arg0, arg1) - ret0, _ := ret[0].(*historyservice.GetDLQMessagesResponse) + ret0, _ := ret[0].(*v1.GetDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1009,10 +1009,10 @@ func (mr *MockHistoryServiceServerMockRecorder) GetDLQMessages(arg0, arg1 interf } // GetDLQReplicationMessages mocks base method. -func (m *MockHistoryServiceServer) GetDLQReplicationMessages(arg0 context.Context, arg1 *historyservice.GetDLQReplicationMessagesRequest) (*historyservice.GetDLQReplicationMessagesResponse, error) { +func (m *MockHistoryServiceServer) GetDLQReplicationMessages(arg0 context.Context, arg1 *v1.GetDLQReplicationMessagesRequest) (*v1.GetDLQReplicationMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetDLQReplicationMessages", arg0, arg1) - ret0, _ := ret[0].(*historyservice.GetDLQReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetDLQReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1024,10 +1024,10 @@ func (mr *MockHistoryServiceServerMockRecorder) GetDLQReplicationMessages(arg0, } // GetMutableState mocks base method. -func (m *MockHistoryServiceServer) GetMutableState(arg0 context.Context, arg1 *historyservice.GetMutableStateRequest) (*historyservice.GetMutableStateResponse, error) { +func (m *MockHistoryServiceServer) GetMutableState(arg0 context.Context, arg1 *v1.GetMutableStateRequest) (*v1.GetMutableStateResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetMutableState", arg0, arg1) - ret0, _ := ret[0].(*historyservice.GetMutableStateResponse) + ret0, _ := ret[0].(*v1.GetMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1039,10 +1039,10 @@ func (mr *MockHistoryServiceServerMockRecorder) GetMutableState(arg0, arg1 inter } // GetReplicationMessages mocks base method. -func (m *MockHistoryServiceServer) GetReplicationMessages(arg0 context.Context, arg1 *historyservice.GetReplicationMessagesRequest) (*historyservice.GetReplicationMessagesResponse, error) { +func (m *MockHistoryServiceServer) GetReplicationMessages(arg0 context.Context, arg1 *v1.GetReplicationMessagesRequest) (*v1.GetReplicationMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetReplicationMessages", arg0, arg1) - ret0, _ := ret[0].(*historyservice.GetReplicationMessagesResponse) + ret0, _ := ret[0].(*v1.GetReplicationMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1054,10 +1054,10 @@ func (mr *MockHistoryServiceServerMockRecorder) GetReplicationMessages(arg0, arg } // GetReplicationStatus mocks base method. -func (m *MockHistoryServiceServer) GetReplicationStatus(arg0 context.Context, arg1 *historyservice.GetReplicationStatusRequest) (*historyservice.GetReplicationStatusResponse, error) { +func (m *MockHistoryServiceServer) GetReplicationStatus(arg0 context.Context, arg1 *v1.GetReplicationStatusRequest) (*v1.GetReplicationStatusResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetReplicationStatus", arg0, arg1) - ret0, _ := ret[0].(*historyservice.GetReplicationStatusResponse) + ret0, _ := ret[0].(*v1.GetReplicationStatusResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1069,10 +1069,10 @@ func (mr *MockHistoryServiceServerMockRecorder) GetReplicationStatus(arg0, arg1 } // GetShard mocks base method. -func (m *MockHistoryServiceServer) GetShard(arg0 context.Context, arg1 *historyservice.GetShardRequest) (*historyservice.GetShardResponse, error) { +func (m *MockHistoryServiceServer) GetShard(arg0 context.Context, arg1 *v1.GetShardRequest) (*v1.GetShardResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetShard", arg0, arg1) - ret0, _ := ret[0].(*historyservice.GetShardResponse) + ret0, _ := ret[0].(*v1.GetShardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1084,10 +1084,10 @@ func (mr *MockHistoryServiceServerMockRecorder) GetShard(arg0, arg1 interface{}) } // MergeDLQMessages mocks base method. -func (m *MockHistoryServiceServer) MergeDLQMessages(arg0 context.Context, arg1 *historyservice.MergeDLQMessagesRequest) (*historyservice.MergeDLQMessagesResponse, error) { +func (m *MockHistoryServiceServer) MergeDLQMessages(arg0 context.Context, arg1 *v1.MergeDLQMessagesRequest) (*v1.MergeDLQMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MergeDLQMessages", arg0, arg1) - ret0, _ := ret[0].(*historyservice.MergeDLQMessagesResponse) + ret0, _ := ret[0].(*v1.MergeDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1099,10 +1099,10 @@ func (mr *MockHistoryServiceServerMockRecorder) MergeDLQMessages(arg0, arg1 inte } // PollMutableState mocks base method. -func (m *MockHistoryServiceServer) PollMutableState(arg0 context.Context, arg1 *historyservice.PollMutableStateRequest) (*historyservice.PollMutableStateResponse, error) { +func (m *MockHistoryServiceServer) PollMutableState(arg0 context.Context, arg1 *v1.PollMutableStateRequest) (*v1.PollMutableStateResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PollMutableState", arg0, arg1) - ret0, _ := ret[0].(*historyservice.PollMutableStateResponse) + ret0, _ := ret[0].(*v1.PollMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1114,10 +1114,10 @@ func (mr *MockHistoryServiceServerMockRecorder) PollMutableState(arg0, arg1 inte } // PurgeDLQMessages mocks base method. -func (m *MockHistoryServiceServer) PurgeDLQMessages(arg0 context.Context, arg1 *historyservice.PurgeDLQMessagesRequest) (*historyservice.PurgeDLQMessagesResponse, error) { +func (m *MockHistoryServiceServer) PurgeDLQMessages(arg0 context.Context, arg1 *v1.PurgeDLQMessagesRequest) (*v1.PurgeDLQMessagesResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PurgeDLQMessages", arg0, arg1) - ret0, _ := ret[0].(*historyservice.PurgeDLQMessagesResponse) + ret0, _ := ret[0].(*v1.PurgeDLQMessagesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1129,10 +1129,10 @@ func (mr *MockHistoryServiceServerMockRecorder) PurgeDLQMessages(arg0, arg1 inte } // QueryWorkflow mocks base method. -func (m *MockHistoryServiceServer) QueryWorkflow(arg0 context.Context, arg1 *historyservice.QueryWorkflowRequest) (*historyservice.QueryWorkflowResponse, error) { +func (m *MockHistoryServiceServer) QueryWorkflow(arg0 context.Context, arg1 *v1.QueryWorkflowRequest) (*v1.QueryWorkflowResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "QueryWorkflow", arg0, arg1) - ret0, _ := ret[0].(*historyservice.QueryWorkflowResponse) + ret0, _ := ret[0].(*v1.QueryWorkflowResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1144,10 +1144,10 @@ func (mr *MockHistoryServiceServerMockRecorder) QueryWorkflow(arg0, arg1 interfa } // ReapplyEvents mocks base method. -func (m *MockHistoryServiceServer) ReapplyEvents(arg0 context.Context, arg1 *historyservice.ReapplyEventsRequest) (*historyservice.ReapplyEventsResponse, error) { +func (m *MockHistoryServiceServer) ReapplyEvents(arg0 context.Context, arg1 *v1.ReapplyEventsRequest) (*v1.ReapplyEventsResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReapplyEvents", arg0, arg1) - ret0, _ := ret[0].(*historyservice.ReapplyEventsResponse) + ret0, _ := ret[0].(*v1.ReapplyEventsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1159,10 +1159,10 @@ func (mr *MockHistoryServiceServerMockRecorder) ReapplyEvents(arg0, arg1 interfa } // RebuildMutableState mocks base method. -func (m *MockHistoryServiceServer) RebuildMutableState(arg0 context.Context, arg1 *historyservice.RebuildMutableStateRequest) (*historyservice.RebuildMutableStateResponse, error) { +func (m *MockHistoryServiceServer) RebuildMutableState(arg0 context.Context, arg1 *v1.RebuildMutableStateRequest) (*v1.RebuildMutableStateResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RebuildMutableState", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RebuildMutableStateResponse) + ret0, _ := ret[0].(*v1.RebuildMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1174,10 +1174,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RebuildMutableState(arg0, arg1 i } // RecordActivityTaskHeartbeat mocks base method. -func (m *MockHistoryServiceServer) RecordActivityTaskHeartbeat(arg0 context.Context, arg1 *historyservice.RecordActivityTaskHeartbeatRequest) (*historyservice.RecordActivityTaskHeartbeatResponse, error) { +func (m *MockHistoryServiceServer) RecordActivityTaskHeartbeat(arg0 context.Context, arg1 *v1.RecordActivityTaskHeartbeatRequest) (*v1.RecordActivityTaskHeartbeatResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RecordActivityTaskHeartbeat", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RecordActivityTaskHeartbeatResponse) + ret0, _ := ret[0].(*v1.RecordActivityTaskHeartbeatResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1189,10 +1189,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RecordActivityTaskHeartbeat(arg0 } // RecordActivityTaskStarted mocks base method. -func (m *MockHistoryServiceServer) RecordActivityTaskStarted(arg0 context.Context, arg1 *historyservice.RecordActivityTaskStartedRequest) (*historyservice.RecordActivityTaskStartedResponse, error) { +func (m *MockHistoryServiceServer) RecordActivityTaskStarted(arg0 context.Context, arg1 *v1.RecordActivityTaskStartedRequest) (*v1.RecordActivityTaskStartedResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RecordActivityTaskStarted", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RecordActivityTaskStartedResponse) + ret0, _ := ret[0].(*v1.RecordActivityTaskStartedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1204,10 +1204,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RecordActivityTaskStarted(arg0, } // RecordChildExecutionCompleted mocks base method. -func (m *MockHistoryServiceServer) RecordChildExecutionCompleted(arg0 context.Context, arg1 *historyservice.RecordChildExecutionCompletedRequest) (*historyservice.RecordChildExecutionCompletedResponse, error) { +func (m *MockHistoryServiceServer) RecordChildExecutionCompleted(arg0 context.Context, arg1 *v1.RecordChildExecutionCompletedRequest) (*v1.RecordChildExecutionCompletedResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RecordChildExecutionCompleted", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RecordChildExecutionCompletedResponse) + ret0, _ := ret[0].(*v1.RecordChildExecutionCompletedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1219,10 +1219,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RecordChildExecutionCompleted(ar } // RecordWorkflowTaskStarted mocks base method. -func (m *MockHistoryServiceServer) RecordWorkflowTaskStarted(arg0 context.Context, arg1 *historyservice.RecordWorkflowTaskStartedRequest) (*historyservice.RecordWorkflowTaskStartedResponse, error) { +func (m *MockHistoryServiceServer) RecordWorkflowTaskStarted(arg0 context.Context, arg1 *v1.RecordWorkflowTaskStartedRequest) (*v1.RecordWorkflowTaskStartedResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RecordWorkflowTaskStarted", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RecordWorkflowTaskStartedResponse) + ret0, _ := ret[0].(*v1.RecordWorkflowTaskStartedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1234,10 +1234,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RecordWorkflowTaskStarted(arg0, } // RefreshWorkflowTasks mocks base method. -func (m *MockHistoryServiceServer) RefreshWorkflowTasks(arg0 context.Context, arg1 *historyservice.RefreshWorkflowTasksRequest) (*historyservice.RefreshWorkflowTasksResponse, error) { +func (m *MockHistoryServiceServer) RefreshWorkflowTasks(arg0 context.Context, arg1 *v1.RefreshWorkflowTasksRequest) (*v1.RefreshWorkflowTasksResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RefreshWorkflowTasks", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RefreshWorkflowTasksResponse) + ret0, _ := ret[0].(*v1.RefreshWorkflowTasksResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1249,10 +1249,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RefreshWorkflowTasks(arg0, arg1 } // RemoveSignalMutableState mocks base method. -func (m *MockHistoryServiceServer) RemoveSignalMutableState(arg0 context.Context, arg1 *historyservice.RemoveSignalMutableStateRequest) (*historyservice.RemoveSignalMutableStateResponse, error) { +func (m *MockHistoryServiceServer) RemoveSignalMutableState(arg0 context.Context, arg1 *v1.RemoveSignalMutableStateRequest) (*v1.RemoveSignalMutableStateResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveSignalMutableState", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RemoveSignalMutableStateResponse) + ret0, _ := ret[0].(*v1.RemoveSignalMutableStateResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1264,10 +1264,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RemoveSignalMutableState(arg0, a } // RemoveTask mocks base method. -func (m *MockHistoryServiceServer) RemoveTask(arg0 context.Context, arg1 *historyservice.RemoveTaskRequest) (*historyservice.RemoveTaskResponse, error) { +func (m *MockHistoryServiceServer) RemoveTask(arg0 context.Context, arg1 *v1.RemoveTaskRequest) (*v1.RemoveTaskResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTask", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RemoveTaskResponse) + ret0, _ := ret[0].(*v1.RemoveTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1279,10 +1279,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RemoveTask(arg0, arg1 interface{ } // ReplicateEventsV2 mocks base method. -func (m *MockHistoryServiceServer) ReplicateEventsV2(arg0 context.Context, arg1 *historyservice.ReplicateEventsV2Request) (*historyservice.ReplicateEventsV2Response, error) { +func (m *MockHistoryServiceServer) ReplicateEventsV2(arg0 context.Context, arg1 *v1.ReplicateEventsV2Request) (*v1.ReplicateEventsV2Response, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReplicateEventsV2", arg0, arg1) - ret0, _ := ret[0].(*historyservice.ReplicateEventsV2Response) + ret0, _ := ret[0].(*v1.ReplicateEventsV2Response) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1294,10 +1294,10 @@ func (mr *MockHistoryServiceServerMockRecorder) ReplicateEventsV2(arg0, arg1 int } // RequestCancelWorkflowExecution mocks base method. -func (m *MockHistoryServiceServer) RequestCancelWorkflowExecution(arg0 context.Context, arg1 *historyservice.RequestCancelWorkflowExecutionRequest) (*historyservice.RequestCancelWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceServer) RequestCancelWorkflowExecution(arg0 context.Context, arg1 *v1.RequestCancelWorkflowExecutionRequest) (*v1.RequestCancelWorkflowExecutionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RequestCancelWorkflowExecution", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RequestCancelWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.RequestCancelWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1309,10 +1309,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RequestCancelWorkflowExecution(a } // ResetStickyTaskQueue mocks base method. -func (m *MockHistoryServiceServer) ResetStickyTaskQueue(arg0 context.Context, arg1 *historyservice.ResetStickyTaskQueueRequest) (*historyservice.ResetStickyTaskQueueResponse, error) { +func (m *MockHistoryServiceServer) ResetStickyTaskQueue(arg0 context.Context, arg1 *v1.ResetStickyTaskQueueRequest) (*v1.ResetStickyTaskQueueResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ResetStickyTaskQueue", arg0, arg1) - ret0, _ := ret[0].(*historyservice.ResetStickyTaskQueueResponse) + ret0, _ := ret[0].(*v1.ResetStickyTaskQueueResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1324,10 +1324,10 @@ func (mr *MockHistoryServiceServerMockRecorder) ResetStickyTaskQueue(arg0, arg1 } // ResetWorkflowExecution mocks base method. -func (m *MockHistoryServiceServer) ResetWorkflowExecution(arg0 context.Context, arg1 *historyservice.ResetWorkflowExecutionRequest) (*historyservice.ResetWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceServer) ResetWorkflowExecution(arg0 context.Context, arg1 *v1.ResetWorkflowExecutionRequest) (*v1.ResetWorkflowExecutionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ResetWorkflowExecution", arg0, arg1) - ret0, _ := ret[0].(*historyservice.ResetWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.ResetWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1339,10 +1339,10 @@ func (mr *MockHistoryServiceServerMockRecorder) ResetWorkflowExecution(arg0, arg } // RespondActivityTaskCanceled mocks base method. -func (m *MockHistoryServiceServer) RespondActivityTaskCanceled(arg0 context.Context, arg1 *historyservice.RespondActivityTaskCanceledRequest) (*historyservice.RespondActivityTaskCanceledResponse, error) { +func (m *MockHistoryServiceServer) RespondActivityTaskCanceled(arg0 context.Context, arg1 *v1.RespondActivityTaskCanceledRequest) (*v1.RespondActivityTaskCanceledResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RespondActivityTaskCanceled", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RespondActivityTaskCanceledResponse) + ret0, _ := ret[0].(*v1.RespondActivityTaskCanceledResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1354,10 +1354,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RespondActivityTaskCanceled(arg0 } // RespondActivityTaskCompleted mocks base method. -func (m *MockHistoryServiceServer) RespondActivityTaskCompleted(arg0 context.Context, arg1 *historyservice.RespondActivityTaskCompletedRequest) (*historyservice.RespondActivityTaskCompletedResponse, error) { +func (m *MockHistoryServiceServer) RespondActivityTaskCompleted(arg0 context.Context, arg1 *v1.RespondActivityTaskCompletedRequest) (*v1.RespondActivityTaskCompletedResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RespondActivityTaskCompleted", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RespondActivityTaskCompletedResponse) + ret0, _ := ret[0].(*v1.RespondActivityTaskCompletedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1369,10 +1369,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RespondActivityTaskCompleted(arg } // RespondActivityTaskFailed mocks base method. -func (m *MockHistoryServiceServer) RespondActivityTaskFailed(arg0 context.Context, arg1 *historyservice.RespondActivityTaskFailedRequest) (*historyservice.RespondActivityTaskFailedResponse, error) { +func (m *MockHistoryServiceServer) RespondActivityTaskFailed(arg0 context.Context, arg1 *v1.RespondActivityTaskFailedRequest) (*v1.RespondActivityTaskFailedResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RespondActivityTaskFailed", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RespondActivityTaskFailedResponse) + ret0, _ := ret[0].(*v1.RespondActivityTaskFailedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1384,10 +1384,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RespondActivityTaskFailed(arg0, } // RespondWorkflowTaskCompleted mocks base method. -func (m *MockHistoryServiceServer) RespondWorkflowTaskCompleted(arg0 context.Context, arg1 *historyservice.RespondWorkflowTaskCompletedRequest) (*historyservice.RespondWorkflowTaskCompletedResponse, error) { +func (m *MockHistoryServiceServer) RespondWorkflowTaskCompleted(arg0 context.Context, arg1 *v1.RespondWorkflowTaskCompletedRequest) (*v1.RespondWorkflowTaskCompletedResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RespondWorkflowTaskCompleted", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RespondWorkflowTaskCompletedResponse) + ret0, _ := ret[0].(*v1.RespondWorkflowTaskCompletedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1399,10 +1399,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RespondWorkflowTaskCompleted(arg } // RespondWorkflowTaskFailed mocks base method. -func (m *MockHistoryServiceServer) RespondWorkflowTaskFailed(arg0 context.Context, arg1 *historyservice.RespondWorkflowTaskFailedRequest) (*historyservice.RespondWorkflowTaskFailedResponse, error) { +func (m *MockHistoryServiceServer) RespondWorkflowTaskFailed(arg0 context.Context, arg1 *v1.RespondWorkflowTaskFailedRequest) (*v1.RespondWorkflowTaskFailedResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RespondWorkflowTaskFailed", arg0, arg1) - ret0, _ := ret[0].(*historyservice.RespondWorkflowTaskFailedResponse) + ret0, _ := ret[0].(*v1.RespondWorkflowTaskFailedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1414,10 +1414,10 @@ func (mr *MockHistoryServiceServerMockRecorder) RespondWorkflowTaskFailed(arg0, } // ScheduleWorkflowTask mocks base method. -func (m *MockHistoryServiceServer) ScheduleWorkflowTask(arg0 context.Context, arg1 *historyservice.ScheduleWorkflowTaskRequest) (*historyservice.ScheduleWorkflowTaskResponse, error) { +func (m *MockHistoryServiceServer) ScheduleWorkflowTask(arg0 context.Context, arg1 *v1.ScheduleWorkflowTaskRequest) (*v1.ScheduleWorkflowTaskResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ScheduleWorkflowTask", arg0, arg1) - ret0, _ := ret[0].(*historyservice.ScheduleWorkflowTaskResponse) + ret0, _ := ret[0].(*v1.ScheduleWorkflowTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1429,10 +1429,10 @@ func (mr *MockHistoryServiceServerMockRecorder) ScheduleWorkflowTask(arg0, arg1 } // SignalWithStartWorkflowExecution mocks base method. -func (m *MockHistoryServiceServer) SignalWithStartWorkflowExecution(arg0 context.Context, arg1 *historyservice.SignalWithStartWorkflowExecutionRequest) (*historyservice.SignalWithStartWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceServer) SignalWithStartWorkflowExecution(arg0 context.Context, arg1 *v1.SignalWithStartWorkflowExecutionRequest) (*v1.SignalWithStartWorkflowExecutionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SignalWithStartWorkflowExecution", arg0, arg1) - ret0, _ := ret[0].(*historyservice.SignalWithStartWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.SignalWithStartWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1444,10 +1444,10 @@ func (mr *MockHistoryServiceServerMockRecorder) SignalWithStartWorkflowExecution } // SignalWorkflowExecution mocks base method. -func (m *MockHistoryServiceServer) SignalWorkflowExecution(arg0 context.Context, arg1 *historyservice.SignalWorkflowExecutionRequest) (*historyservice.SignalWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceServer) SignalWorkflowExecution(arg0 context.Context, arg1 *v1.SignalWorkflowExecutionRequest) (*v1.SignalWorkflowExecutionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SignalWorkflowExecution", arg0, arg1) - ret0, _ := ret[0].(*historyservice.SignalWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.SignalWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1459,10 +1459,10 @@ func (mr *MockHistoryServiceServerMockRecorder) SignalWorkflowExecution(arg0, ar } // StartWorkflowExecution mocks base method. -func (m *MockHistoryServiceServer) StartWorkflowExecution(arg0 context.Context, arg1 *historyservice.StartWorkflowExecutionRequest) (*historyservice.StartWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceServer) StartWorkflowExecution(arg0 context.Context, arg1 *v1.StartWorkflowExecutionRequest) (*v1.StartWorkflowExecutionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StartWorkflowExecution", arg0, arg1) - ret0, _ := ret[0].(*historyservice.StartWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.StartWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1474,10 +1474,10 @@ func (mr *MockHistoryServiceServerMockRecorder) StartWorkflowExecution(arg0, arg } // SyncActivity mocks base method. -func (m *MockHistoryServiceServer) SyncActivity(arg0 context.Context, arg1 *historyservice.SyncActivityRequest) (*historyservice.SyncActivityResponse, error) { +func (m *MockHistoryServiceServer) SyncActivity(arg0 context.Context, arg1 *v1.SyncActivityRequest) (*v1.SyncActivityResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SyncActivity", arg0, arg1) - ret0, _ := ret[0].(*historyservice.SyncActivityResponse) + ret0, _ := ret[0].(*v1.SyncActivityResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1489,10 +1489,10 @@ func (mr *MockHistoryServiceServerMockRecorder) SyncActivity(arg0, arg1 interfac } // SyncShardStatus mocks base method. -func (m *MockHistoryServiceServer) SyncShardStatus(arg0 context.Context, arg1 *historyservice.SyncShardStatusRequest) (*historyservice.SyncShardStatusResponse, error) { +func (m *MockHistoryServiceServer) SyncShardStatus(arg0 context.Context, arg1 *v1.SyncShardStatusRequest) (*v1.SyncShardStatusResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SyncShardStatus", arg0, arg1) - ret0, _ := ret[0].(*historyservice.SyncShardStatusResponse) + ret0, _ := ret[0].(*v1.SyncShardStatusResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1504,10 +1504,10 @@ func (mr *MockHistoryServiceServerMockRecorder) SyncShardStatus(arg0, arg1 inter } // TerminateWorkflowExecution mocks base method. -func (m *MockHistoryServiceServer) TerminateWorkflowExecution(arg0 context.Context, arg1 *historyservice.TerminateWorkflowExecutionRequest) (*historyservice.TerminateWorkflowExecutionResponse, error) { +func (m *MockHistoryServiceServer) TerminateWorkflowExecution(arg0 context.Context, arg1 *v1.TerminateWorkflowExecutionRequest) (*v1.TerminateWorkflowExecutionResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "TerminateWorkflowExecution", arg0, arg1) - ret0, _ := ret[0].(*historyservice.TerminateWorkflowExecutionResponse) + ret0, _ := ret[0].(*v1.TerminateWorkflowExecutionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } diff --git a/api/matchingservicemock/v1/service.pb.mock.go b/api/matchingservicemock/v1/service.pb.mock.go index 3515a4ddd7c..aca118c86ba 100644 --- a/api/matchingservicemock/v1/service.pb.mock.go +++ b/api/matchingservicemock/v1/service.pb.mock.go @@ -33,7 +33,7 @@ import ( reflect "reflect" gomock "github.com/golang/mock/gomock" - matchingservice "go.temporal.io/server/api/matchingservice/v1" + v1 "go.temporal.io/server/api/matchingservice/v1" grpc "google.golang.org/grpc" ) @@ -61,14 +61,14 @@ func (m *MockMatchingServiceClient) EXPECT() *MockMatchingServiceClientMockRecor } // AddActivityTask mocks base method. -func (m *MockMatchingServiceClient) AddActivityTask(ctx context.Context, in *matchingservice.AddActivityTaskRequest, opts ...grpc.CallOption) (*matchingservice.AddActivityTaskResponse, error) { +func (m *MockMatchingServiceClient) AddActivityTask(ctx context.Context, in *v1.AddActivityTaskRequest, opts ...grpc.CallOption) (*v1.AddActivityTaskResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AddActivityTask", varargs...) - ret0, _ := ret[0].(*matchingservice.AddActivityTaskResponse) + ret0, _ := ret[0].(*v1.AddActivityTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -81,14 +81,14 @@ func (mr *MockMatchingServiceClientMockRecorder) AddActivityTask(ctx, in interfa } // AddWorkflowTask mocks base method. -func (m *MockMatchingServiceClient) AddWorkflowTask(ctx context.Context, in *matchingservice.AddWorkflowTaskRequest, opts ...grpc.CallOption) (*matchingservice.AddWorkflowTaskResponse, error) { +func (m *MockMatchingServiceClient) AddWorkflowTask(ctx context.Context, in *v1.AddWorkflowTaskRequest, opts ...grpc.CallOption) (*v1.AddWorkflowTaskResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AddWorkflowTask", varargs...) - ret0, _ := ret[0].(*matchingservice.AddWorkflowTaskResponse) + ret0, _ := ret[0].(*v1.AddWorkflowTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -101,14 +101,14 @@ func (mr *MockMatchingServiceClientMockRecorder) AddWorkflowTask(ctx, in interfa } // CancelOutstandingPoll mocks base method. -func (m *MockMatchingServiceClient) CancelOutstandingPoll(ctx context.Context, in *matchingservice.CancelOutstandingPollRequest, opts ...grpc.CallOption) (*matchingservice.CancelOutstandingPollResponse, error) { +func (m *MockMatchingServiceClient) CancelOutstandingPoll(ctx context.Context, in *v1.CancelOutstandingPollRequest, opts ...grpc.CallOption) (*v1.CancelOutstandingPollResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CancelOutstandingPoll", varargs...) - ret0, _ := ret[0].(*matchingservice.CancelOutstandingPollResponse) + ret0, _ := ret[0].(*v1.CancelOutstandingPollResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -121,14 +121,14 @@ func (mr *MockMatchingServiceClientMockRecorder) CancelOutstandingPoll(ctx, in i } // DescribeTaskQueue mocks base method. -func (m *MockMatchingServiceClient) DescribeTaskQueue(ctx context.Context, in *matchingservice.DescribeTaskQueueRequest, opts ...grpc.CallOption) (*matchingservice.DescribeTaskQueueResponse, error) { +func (m *MockMatchingServiceClient) DescribeTaskQueue(ctx context.Context, in *v1.DescribeTaskQueueRequest, opts ...grpc.CallOption) (*v1.DescribeTaskQueueResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeTaskQueue", varargs...) - ret0, _ := ret[0].(*matchingservice.DescribeTaskQueueResponse) + ret0, _ := ret[0].(*v1.DescribeTaskQueueResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -141,14 +141,14 @@ func (mr *MockMatchingServiceClientMockRecorder) DescribeTaskQueue(ctx, in inter } // ListTaskQueuePartitions mocks base method. -func (m *MockMatchingServiceClient) ListTaskQueuePartitions(ctx context.Context, in *matchingservice.ListTaskQueuePartitionsRequest, opts ...grpc.CallOption) (*matchingservice.ListTaskQueuePartitionsResponse, error) { +func (m *MockMatchingServiceClient) ListTaskQueuePartitions(ctx context.Context, in *v1.ListTaskQueuePartitionsRequest, opts ...grpc.CallOption) (*v1.ListTaskQueuePartitionsResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListTaskQueuePartitions", varargs...) - ret0, _ := ret[0].(*matchingservice.ListTaskQueuePartitionsResponse) + ret0, _ := ret[0].(*v1.ListTaskQueuePartitionsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -161,14 +161,14 @@ func (mr *MockMatchingServiceClientMockRecorder) ListTaskQueuePartitions(ctx, in } // PollActivityTaskQueue mocks base method. -func (m *MockMatchingServiceClient) PollActivityTaskQueue(ctx context.Context, in *matchingservice.PollActivityTaskQueueRequest, opts ...grpc.CallOption) (*matchingservice.PollActivityTaskQueueResponse, error) { +func (m *MockMatchingServiceClient) PollActivityTaskQueue(ctx context.Context, in *v1.PollActivityTaskQueueRequest, opts ...grpc.CallOption) (*v1.PollActivityTaskQueueResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PollActivityTaskQueue", varargs...) - ret0, _ := ret[0].(*matchingservice.PollActivityTaskQueueResponse) + ret0, _ := ret[0].(*v1.PollActivityTaskQueueResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -181,14 +181,14 @@ func (mr *MockMatchingServiceClientMockRecorder) PollActivityTaskQueue(ctx, in i } // PollWorkflowTaskQueue mocks base method. -func (m *MockMatchingServiceClient) PollWorkflowTaskQueue(ctx context.Context, in *matchingservice.PollWorkflowTaskQueueRequest, opts ...grpc.CallOption) (*matchingservice.PollWorkflowTaskQueueResponse, error) { +func (m *MockMatchingServiceClient) PollWorkflowTaskQueue(ctx context.Context, in *v1.PollWorkflowTaskQueueRequest, opts ...grpc.CallOption) (*v1.PollWorkflowTaskQueueResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PollWorkflowTaskQueue", varargs...) - ret0, _ := ret[0].(*matchingservice.PollWorkflowTaskQueueResponse) + ret0, _ := ret[0].(*v1.PollWorkflowTaskQueueResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -201,14 +201,14 @@ func (mr *MockMatchingServiceClientMockRecorder) PollWorkflowTaskQueue(ctx, in i } // QueryWorkflow mocks base method. -func (m *MockMatchingServiceClient) QueryWorkflow(ctx context.Context, in *matchingservice.QueryWorkflowRequest, opts ...grpc.CallOption) (*matchingservice.QueryWorkflowResponse, error) { +func (m *MockMatchingServiceClient) QueryWorkflow(ctx context.Context, in *v1.QueryWorkflowRequest, opts ...grpc.CallOption) (*v1.QueryWorkflowResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "QueryWorkflow", varargs...) - ret0, _ := ret[0].(*matchingservice.QueryWorkflowResponse) + ret0, _ := ret[0].(*v1.QueryWorkflowResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -221,14 +221,14 @@ func (mr *MockMatchingServiceClientMockRecorder) QueryWorkflow(ctx, in interface } // RespondQueryTaskCompleted mocks base method. -func (m *MockMatchingServiceClient) RespondQueryTaskCompleted(ctx context.Context, in *matchingservice.RespondQueryTaskCompletedRequest, opts ...grpc.CallOption) (*matchingservice.RespondQueryTaskCompletedResponse, error) { +func (m *MockMatchingServiceClient) RespondQueryTaskCompleted(ctx context.Context, in *v1.RespondQueryTaskCompletedRequest, opts ...grpc.CallOption) (*v1.RespondQueryTaskCompletedResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RespondQueryTaskCompleted", varargs...) - ret0, _ := ret[0].(*matchingservice.RespondQueryTaskCompletedResponse) + ret0, _ := ret[0].(*v1.RespondQueryTaskCompletedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -264,10 +264,10 @@ func (m *MockMatchingServiceServer) EXPECT() *MockMatchingServiceServerMockRecor } // AddActivityTask mocks base method. -func (m *MockMatchingServiceServer) AddActivityTask(arg0 context.Context, arg1 *matchingservice.AddActivityTaskRequest) (*matchingservice.AddActivityTaskResponse, error) { +func (m *MockMatchingServiceServer) AddActivityTask(arg0 context.Context, arg1 *v1.AddActivityTaskRequest) (*v1.AddActivityTaskResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddActivityTask", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.AddActivityTaskResponse) + ret0, _ := ret[0].(*v1.AddActivityTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -279,10 +279,10 @@ func (mr *MockMatchingServiceServerMockRecorder) AddActivityTask(arg0, arg1 inte } // AddWorkflowTask mocks base method. -func (m *MockMatchingServiceServer) AddWorkflowTask(arg0 context.Context, arg1 *matchingservice.AddWorkflowTaskRequest) (*matchingservice.AddWorkflowTaskResponse, error) { +func (m *MockMatchingServiceServer) AddWorkflowTask(arg0 context.Context, arg1 *v1.AddWorkflowTaskRequest) (*v1.AddWorkflowTaskResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddWorkflowTask", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.AddWorkflowTaskResponse) + ret0, _ := ret[0].(*v1.AddWorkflowTaskResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -294,10 +294,10 @@ func (mr *MockMatchingServiceServerMockRecorder) AddWorkflowTask(arg0, arg1 inte } // CancelOutstandingPoll mocks base method. -func (m *MockMatchingServiceServer) CancelOutstandingPoll(arg0 context.Context, arg1 *matchingservice.CancelOutstandingPollRequest) (*matchingservice.CancelOutstandingPollResponse, error) { +func (m *MockMatchingServiceServer) CancelOutstandingPoll(arg0 context.Context, arg1 *v1.CancelOutstandingPollRequest) (*v1.CancelOutstandingPollResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CancelOutstandingPoll", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.CancelOutstandingPollResponse) + ret0, _ := ret[0].(*v1.CancelOutstandingPollResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -309,10 +309,10 @@ func (mr *MockMatchingServiceServerMockRecorder) CancelOutstandingPoll(arg0, arg } // DescribeTaskQueue mocks base method. -func (m *MockMatchingServiceServer) DescribeTaskQueue(arg0 context.Context, arg1 *matchingservice.DescribeTaskQueueRequest) (*matchingservice.DescribeTaskQueueResponse, error) { +func (m *MockMatchingServiceServer) DescribeTaskQueue(arg0 context.Context, arg1 *v1.DescribeTaskQueueRequest) (*v1.DescribeTaskQueueResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeTaskQueue", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.DescribeTaskQueueResponse) + ret0, _ := ret[0].(*v1.DescribeTaskQueueResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -324,10 +324,10 @@ func (mr *MockMatchingServiceServerMockRecorder) DescribeTaskQueue(arg0, arg1 in } // ListTaskQueuePartitions mocks base method. -func (m *MockMatchingServiceServer) ListTaskQueuePartitions(arg0 context.Context, arg1 *matchingservice.ListTaskQueuePartitionsRequest) (*matchingservice.ListTaskQueuePartitionsResponse, error) { +func (m *MockMatchingServiceServer) ListTaskQueuePartitions(arg0 context.Context, arg1 *v1.ListTaskQueuePartitionsRequest) (*v1.ListTaskQueuePartitionsResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTaskQueuePartitions", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.ListTaskQueuePartitionsResponse) + ret0, _ := ret[0].(*v1.ListTaskQueuePartitionsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -339,10 +339,10 @@ func (mr *MockMatchingServiceServerMockRecorder) ListTaskQueuePartitions(arg0, a } // PollActivityTaskQueue mocks base method. -func (m *MockMatchingServiceServer) PollActivityTaskQueue(arg0 context.Context, arg1 *matchingservice.PollActivityTaskQueueRequest) (*matchingservice.PollActivityTaskQueueResponse, error) { +func (m *MockMatchingServiceServer) PollActivityTaskQueue(arg0 context.Context, arg1 *v1.PollActivityTaskQueueRequest) (*v1.PollActivityTaskQueueResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PollActivityTaskQueue", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.PollActivityTaskQueueResponse) + ret0, _ := ret[0].(*v1.PollActivityTaskQueueResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -354,10 +354,10 @@ func (mr *MockMatchingServiceServerMockRecorder) PollActivityTaskQueue(arg0, arg } // PollWorkflowTaskQueue mocks base method. -func (m *MockMatchingServiceServer) PollWorkflowTaskQueue(arg0 context.Context, arg1 *matchingservice.PollWorkflowTaskQueueRequest) (*matchingservice.PollWorkflowTaskQueueResponse, error) { +func (m *MockMatchingServiceServer) PollWorkflowTaskQueue(arg0 context.Context, arg1 *v1.PollWorkflowTaskQueueRequest) (*v1.PollWorkflowTaskQueueResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PollWorkflowTaskQueue", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.PollWorkflowTaskQueueResponse) + ret0, _ := ret[0].(*v1.PollWorkflowTaskQueueResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -369,10 +369,10 @@ func (mr *MockMatchingServiceServerMockRecorder) PollWorkflowTaskQueue(arg0, arg } // QueryWorkflow mocks base method. -func (m *MockMatchingServiceServer) QueryWorkflow(arg0 context.Context, arg1 *matchingservice.QueryWorkflowRequest) (*matchingservice.QueryWorkflowResponse, error) { +func (m *MockMatchingServiceServer) QueryWorkflow(arg0 context.Context, arg1 *v1.QueryWorkflowRequest) (*v1.QueryWorkflowResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "QueryWorkflow", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.QueryWorkflowResponse) + ret0, _ := ret[0].(*v1.QueryWorkflowResponse) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -384,10 +384,10 @@ func (mr *MockMatchingServiceServerMockRecorder) QueryWorkflow(arg0, arg1 interf } // RespondQueryTaskCompleted mocks base method. -func (m *MockMatchingServiceServer) RespondQueryTaskCompleted(arg0 context.Context, arg1 *matchingservice.RespondQueryTaskCompletedRequest) (*matchingservice.RespondQueryTaskCompletedResponse, error) { +func (m *MockMatchingServiceServer) RespondQueryTaskCompleted(arg0 context.Context, arg1 *v1.RespondQueryTaskCompletedRequest) (*v1.RespondQueryTaskCompletedResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RespondQueryTaskCompleted", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.RespondQueryTaskCompletedResponse) + ret0, _ := ret[0].(*v1.RespondQueryTaskCompletedResponse) ret1, _ := ret[1].(error) return ret0, ret1 } diff --git a/go.mod b/go.mod index f60444dc57f..7b738722c7e 100644 --- a/go.mod +++ b/go.mod @@ -44,7 +44,7 @@ require ( go.opentelemetry.io/otel/sdk v1.4.0 go.opentelemetry.io/otel/sdk/export/metric v0.27.0 go.opentelemetry.io/otel/sdk/metric v0.27.0 - go.temporal.io/api v1.7.1-0.20220308002655-96f7fbf5da40 + go.temporal.io/api v1.7.1-0.20220321175358-f623ba3ce7d4 go.temporal.io/sdk v1.13.0 go.temporal.io/version v0.3.0 go.uber.org/atomic v1.9.0 @@ -54,15 +54,13 @@ require ( golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 golang.org/x/time v0.0.0-20220210224613-90d013bbcef8 google.golang.org/api v0.68.0 - google.golang.org/grpc v1.44.0 + google.golang.org/grpc v1.45.0 google.golang.org/grpc/examples v0.0.0-20220210231334-75fd0240ac41 gopkg.in/square/go-jose.v2 v2.6.0 gopkg.in/validator.v2 v2.0.0-20210331031555-b37d688a7fb0 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b ) -replace go.temporal.io/api => /Users/ycyang/temporalio/api-go // TODO: remove after api change is landed - require ( cloud.google.com/go v0.100.2 // indirect cloud.google.com/go/compute v1.2.0 // indirect @@ -115,11 +113,11 @@ require ( go.uber.org/dig v1.13.0 // indirect golang.org/x/crypto v0.0.0-20220210151621-f4118a5b28e2 // indirect golang.org/x/net v0.0.0-20220225172249-27dd8689420f // indirect - golang.org/x/sys v0.0.0-20220307203707-22a9840ba4d7 // indirect + golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8 // indirect golang.org/x/text v0.3.7 // indirect golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect google.golang.org/appengine v1.6.7 // indirect - google.golang.org/genproto v0.0.0-20220307174427-659dce7fcb03 // indirect + google.golang.org/genproto v0.0.0-20220317150908-0efb43f6373e // indirect google.golang.org/protobuf v1.27.1 // indirect gopkg.in/inf.v0 v0.9.1 // indirect ) diff --git a/go.sum b/go.sum index 73a3420e91a..21360fe82a5 100644 --- a/go.sum +++ b/go.sum @@ -476,6 +476,9 @@ go.opentelemetry.io/otel/sdk/metric v0.27.0/go.mod h1:lOgrT5C3ORdbqp2LsDrx+pBj6g go.opentelemetry.io/otel/trace v1.4.0 h1:4OOUrPZdVFQkbzl/JSdvGCWIdw5ONXXxzHlaLlWppmo= go.opentelemetry.io/otel/trace v1.4.0/go.mod h1:uc3eRsqDfWs9R7b92xbQbU42/eTNz4N+gLP8qJCi4aE= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.temporal.io/api v1.6.1-0.20211110205628-60c98e9cbfe2/go.mod h1:IlUgOTGfmJuOkGrCZdptNxyXKE9CQz6oOx7/aH9bFY4= +go.temporal.io/api v1.7.1-0.20220321175358-f623ba3ce7d4 h1:+jDzci7ob+fSBqmSLfN66f3EG88wyZBcOfiDunkhYUc= +go.temporal.io/api v1.7.1-0.20220321175358-f623ba3ce7d4/go.mod h1:tECxXXsJgzLShh6b8w1zCTrxkQBrrf1UsleZEK8pQlw= go.temporal.io/sdk v1.13.0 h1:8PW27o/uYAf1C1u8WUd6LNa6He2nYkBhdUX3c5gif5o= go.temporal.io/sdk v1.13.0/go.mod h1:TCof7U/xas2FyDnx/UUEv4c/O/S41Lnhva+6JVer+Jo= go.temporal.io/version v0.3.0 h1:dMrei9l9NyHt8nG6EB8vAwDLLTwx2SvRyucCSumAiig= @@ -590,6 +593,7 @@ golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLd golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211109214657-ef0fda0de508/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211216030914-fe4d6282115f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= @@ -684,13 +688,14 @@ golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20210903071746-97244b99971b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211110154304-99a53858aa08/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211210111614-af8b64212486/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-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220204135822-1c1b9b1eba6a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220307203707-22a9840ba4d7 h1:8IVLkfbr2cLhv0a/vKq4UFUcJym8RmDoDboxCFWEjYE= -golang.org/x/sys v0.0.0-20220307203707-22a9840ba4d7/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8 h1:OH54vjqzRWmbJ62fjuhxy7AxFFgoHN0/DPc/UrL8cAs= +golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -876,6 +881,7 @@ google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEc google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211104193956-4c6863e31247/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= @@ -885,8 +891,8 @@ google.golang.org/genproto v0.0.0-20220111164026-67b88f271998/go.mod h1:5CzLGKJ6 google.golang.org/genproto v0.0.0-20220114231437-d2e6a121cae0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20220201184016-50beb8ab5c44/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20220204002441-d6cc3cc0770e/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20220307174427-659dce7fcb03 h1:roRqEkPqsCOa0ViO0CuSwDIVdttRbBMj8oU/2E7pI08= -google.golang.org/genproto v0.0.0-20220307174427-659dce7fcb03/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220317150908-0efb43f6373e h1:fNKDNuUyC4WH+inqDMpfXDdfvwfYILbsX+oskGZ8hxg= +google.golang.org/genproto v0.0.0-20220317150908-0efb43f6373e/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= google.golang.org/grpc v1.8.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= @@ -916,8 +922,8 @@ google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnD google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc v1.44.0 h1:weqSxi/TMs1SqFRMHCtBgXRs8k3X39QIDEZ0pRcttUg= -google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0 h1:NEpgUqV3Z+ZjkqMsxMg11IaDrXY4RY6CQukSGK0uI1M= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= google.golang.org/grpc/examples v0.0.0-20220210231334-75fd0240ac41 h1:50yVy/D+5ZFTrjTeRoEMIuDceCuWpa5e5M+QgCrfjyg= google.golang.org/grpc/examples v0.0.0-20220210231334-75fd0240ac41/go.mod h1:gID3PKrg7pWKntu9Ss6zTLJ0ttC0X9IHgREOCZwbCVU= diff --git a/proto/api b/proto/api index 336a14569b4..bd0759810fe 160000 --- a/proto/api +++ b/proto/api @@ -1 +1 @@ -Subproject commit 336a14569b47d145300989c830cf50ab8ccad577 +Subproject commit bd0759810febac586e426ec808cce7b93fb8bb22 diff --git a/service/history/historyEngine.go b/service/history/historyEngine.go index e804a7f2995..921a8b7a2db 100644 --- a/service/history/historyEngine.go +++ b/service/history/historyEngine.go @@ -3029,6 +3029,11 @@ func (e *historyEngineImpl) applyWorkflowIDReusePolicyForSignalWithStart( ) } +// applyWorkflowIDReusePolicyHelper returns updateWorkflowActionFunc +// for updating the previous execution and an error if the situation is +// not allowed by the workflowIDReusePolicy. +// Both result may be nil, if the case is allow and no update is needed +// for the previous execution. func (e *historyEngineImpl) applyWorkflowIDReusePolicyHelper( prevStartRequestID, prevRunID string, From fdd34b3e6bcda770e3766cc4d704d711a6fd6db8 Mon Sep 17 00:00:00 2001 From: Yichao Yang Date: Mon, 21 Mar 2022 11:14:15 -0700 Subject: [PATCH 4/4] remove named return value --- service/history/historyEngine.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/service/history/historyEngine.go b/service/history/historyEngine.go index dc60db6a96b..19b18090c0e 100644 --- a/service/history/historyEngine.go +++ b/service/history/historyEngine.go @@ -3045,7 +3045,7 @@ func (e *historyEngineImpl) applyWorkflowIDReusePolicyHelper( prevStatus enumspb.WorkflowExecutionStatus, newExecution commonpb.WorkflowExecution, wfIDReusePolicy enumspb.WorkflowIdReusePolicy, -) (prevExecutionUpdateFn updateWorkflowActionFunc, err error) { +) (updateWorkflowActionFunc, error) { // here we know there is some information about the prev workflow, i.e. either running right now // or has history check if the this workflow is finished