mirror of
https://github.com/hanzoai/tasks.git
synced 2026-10-04 02:04:03 +00:00
e806647384
## What changed? Make data loss check in resend history more strict ## Why? 1. Reset workflow could send different part of workflow history and using the same NWR. 2. For data loss case, all fields have to be equal. ## How did you test it? <!-- How have you verified this change? Tested locally? Added a unit test? Checked in staging env? --> ## Potential risks <!-- Assuming the worst case, what can be broken when deploying this change to production? --> ## Documentation <!-- Have you made sure this change doesn't falsify anything currently stated in `docs/`? If significant new behavior is added, have you described that in `docs/`? --> ## Is hotfix candidate? <!-- Is this PR a hotfix candidate or does it require a notification to be sent to the broader community? (Yes/No) --> --------- Co-authored-by: Liang Mei <[email protected]>
635 lines
20 KiB
Go
635 lines
20 KiB
Go
// The MIT License
|
|
//
|
|
// Copyright (c) 2020 Temporal Technologies Inc. All rights reserved.
|
|
//
|
|
// Copyright (c) 2020 Uber Technologies, Inc.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
package replication
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"math/rand"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/golang/mock/gomock"
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/stretchr/testify/suite"
|
|
commonpb "go.temporal.io/api/common/v1"
|
|
"go.temporal.io/api/serviceerror"
|
|
|
|
"go.temporal.io/server/common/dynamicconfig"
|
|
"go.temporal.io/server/service/history/configs"
|
|
"go.temporal.io/server/service/history/replication/eventhandler"
|
|
"go.temporal.io/server/service/history/tests"
|
|
|
|
"go.temporal.io/server/api/historyservice/v1"
|
|
persistencespb "go.temporal.io/server/api/persistence/v1"
|
|
"go.temporal.io/server/client"
|
|
"go.temporal.io/server/common"
|
|
"go.temporal.io/server/common/cluster"
|
|
"go.temporal.io/server/common/log"
|
|
"go.temporal.io/server/common/metrics"
|
|
"go.temporal.io/server/common/namespace"
|
|
"go.temporal.io/server/common/persistence"
|
|
serviceerrors "go.temporal.io/server/common/serviceerror"
|
|
ctasks "go.temporal.io/server/common/tasks"
|
|
"go.temporal.io/server/common/xdc"
|
|
"go.temporal.io/server/service/history/shard"
|
|
)
|
|
|
|
type (
|
|
executableTaskSuite struct {
|
|
suite.Suite
|
|
*require.Assertions
|
|
|
|
controller *gomock.Controller
|
|
clusterMetadata *cluster.MockMetadata
|
|
clientBean *client.MockBean
|
|
shardController *shard.MockController
|
|
namespaceCache *namespace.MockRegistry
|
|
ndcHistoryResender *xdc.MockNDCHistoryResender
|
|
remoteHistoryFetcher *eventhandler.MockHistoryPaginatedFetcher
|
|
metricsHandler metrics.Handler
|
|
logger log.Logger
|
|
sourceCluster string
|
|
eagerNamespaceRefresher *MockEagerNamespaceRefresher
|
|
config *configs.Config
|
|
|
|
task *ExecutableTaskImpl
|
|
}
|
|
)
|
|
|
|
func TestExecutableTaskSuite(t *testing.T) {
|
|
s := new(executableTaskSuite)
|
|
suite.Run(t, s)
|
|
}
|
|
|
|
func (s *executableTaskSuite) SetupSuite() {
|
|
s.Assertions = require.New(s.T())
|
|
}
|
|
|
|
func (s *executableTaskSuite) TearDownSuite() {
|
|
|
|
}
|
|
|
|
func (s *executableTaskSuite) SetupTest() {
|
|
s.controller = gomock.NewController(s.T())
|
|
s.clusterMetadata = cluster.NewMockMetadata(s.controller)
|
|
s.clientBean = client.NewMockBean(s.controller)
|
|
s.shardController = shard.NewMockController(s.controller)
|
|
s.namespaceCache = namespace.NewMockRegistry(s.controller)
|
|
s.ndcHistoryResender = xdc.NewMockNDCHistoryResender(s.controller)
|
|
s.metricsHandler = metrics.NoopMetricsHandler
|
|
s.logger = log.NewNoopLogger()
|
|
s.sourceCluster = "some cluster"
|
|
s.eagerNamespaceRefresher = NewMockEagerNamespaceRefresher(s.controller)
|
|
s.config = tests.NewDynamicConfig()
|
|
s.remoteHistoryFetcher = eventhandler.NewMockHistoryPaginatedFetcher(s.controller)
|
|
|
|
creationTime := time.Unix(0, rand.Int63())
|
|
receivedTime := creationTime.Add(time.Duration(rand.Int63()))
|
|
s.task = NewExecutableTask(
|
|
ProcessToolBox{
|
|
Config: s.config,
|
|
ClusterMetadata: s.clusterMetadata,
|
|
ClientBean: s.clientBean,
|
|
ShardController: s.shardController,
|
|
NamespaceCache: s.namespaceCache,
|
|
NDCHistoryResender: s.ndcHistoryResender,
|
|
MetricsHandler: s.metricsHandler,
|
|
Logger: s.logger,
|
|
EagerNamespaceRefresher: s.eagerNamespaceRefresher,
|
|
DLQWriter: NoopDLQWriter{},
|
|
},
|
|
rand.Int63(),
|
|
"metrics-tag",
|
|
creationTime,
|
|
receivedTime,
|
|
s.sourceCluster,
|
|
)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TearDownTest() {
|
|
s.controller.Finish()
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestTaskID() {
|
|
s.Equal(s.task.taskID, s.task.TaskID())
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestCreationTime() {
|
|
s.Equal(s.task.taskCreationTime, s.task.TaskCreationTime())
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestAckStateAttempt() {
|
|
s.Equal(ctasks.TaskStatePending, s.task.State())
|
|
s.False(s.task.TerminalState())
|
|
|
|
s.task.Ack()
|
|
s.Equal(ctasks.TaskStateAcked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
|
|
s.task.Nack(nil)
|
|
s.Equal(ctasks.TaskStateAcked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Abort()
|
|
s.Equal(ctasks.TaskStateAcked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Cancel()
|
|
s.Equal(ctasks.TaskStateAcked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Reschedule()
|
|
s.Equal(ctasks.TaskStateAcked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
|
|
s.True(s.task.TerminalState())
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestNackStateAttempt() {
|
|
s.Equal(ctasks.TaskStatePending, s.task.State())
|
|
s.False(s.task.TerminalState())
|
|
|
|
s.task.Nack(nil)
|
|
s.Equal(ctasks.TaskStateNacked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
|
|
s.task.Ack()
|
|
s.Equal(ctasks.TaskStateNacked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Abort()
|
|
s.Equal(ctasks.TaskStateNacked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Cancel()
|
|
s.Equal(ctasks.TaskStateNacked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Reschedule()
|
|
s.Equal(ctasks.TaskStateNacked, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
|
|
s.True(s.task.TerminalState())
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestAbortStateAttempt() {
|
|
s.Equal(ctasks.TaskStatePending, s.task.State())
|
|
s.False(s.task.TerminalState())
|
|
|
|
s.task.Abort()
|
|
s.Equal(ctasks.TaskStateAborted, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
|
|
s.task.Ack()
|
|
s.Equal(ctasks.TaskStateAborted, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Nack(nil)
|
|
s.Equal(ctasks.TaskStateAborted, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Cancel()
|
|
s.Equal(ctasks.TaskStateAborted, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Reschedule()
|
|
s.Equal(ctasks.TaskStateAborted, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
|
|
s.True(s.task.TerminalState())
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestCancelStateAttempt() {
|
|
s.Equal(ctasks.TaskStatePending, s.task.State())
|
|
s.False(s.task.TerminalState())
|
|
|
|
s.task.Cancel()
|
|
s.Equal(ctasks.TaskStateCancelled, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
|
|
s.task.Ack()
|
|
s.Equal(ctasks.TaskStateCancelled, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Nack(nil)
|
|
s.Equal(ctasks.TaskStateCancelled, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Abort()
|
|
s.Equal(ctasks.TaskStateCancelled, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
s.task.Reschedule()
|
|
s.Equal(ctasks.TaskStateCancelled, s.task.State())
|
|
s.Equal(1, s.task.Attempt())
|
|
|
|
s.True(s.task.TerminalState())
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestRescheduleStateAttempt() {
|
|
s.Equal(ctasks.TaskStatePending, s.task.State())
|
|
s.False(s.task.TerminalState())
|
|
|
|
s.task.Reschedule()
|
|
s.Equal(ctasks.TaskStatePending, s.task.State())
|
|
s.Equal(2, s.task.Attempt())
|
|
|
|
s.False(s.task.TerminalState())
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestIsRetryableError() {
|
|
err := errors.New("OwO")
|
|
s.True(s.task.IsRetryableError(err))
|
|
|
|
err = serviceerror.NewInternal("OwO")
|
|
s.True(s.task.IsRetryableError(err))
|
|
|
|
err = serviceerror.NewUnavailable("OwO")
|
|
s.True(s.task.IsRetryableError(err))
|
|
|
|
err = serviceerror.NewInvalidArgument("OwO")
|
|
s.False(s.task.IsRetryableError(err))
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestResend_Success() {
|
|
remoteCluster := cluster.TestAlternativeClusterName
|
|
resendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: uuid.NewString(),
|
|
WorkflowId: uuid.NewString(),
|
|
RunId: uuid.NewString(),
|
|
StartEventId: rand.Int63(),
|
|
StartEventVersion: rand.Int63(),
|
|
EndEventId: rand.Int63(),
|
|
EndEventVersion: rand.Int63(),
|
|
}
|
|
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(resendErr.NamespaceId),
|
|
resendErr.WorkflowId,
|
|
resendErr.RunId,
|
|
resendErr.StartEventId,
|
|
resendErr.StartEventVersion,
|
|
resendErr.EndEventId,
|
|
resendErr.EndEventVersion,
|
|
).Return(nil)
|
|
|
|
doContinue, err := s.task.Resend(context.Background(), remoteCluster, resendErr, ResendAttempt)
|
|
s.NoError(err)
|
|
s.True(doContinue)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestResend_NotFound() {
|
|
remoteCluster := cluster.TestAlternativeClusterName
|
|
resendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: uuid.NewString(),
|
|
WorkflowId: uuid.NewString(),
|
|
RunId: uuid.NewString(),
|
|
StartEventId: rand.Int63(),
|
|
StartEventVersion: rand.Int63(),
|
|
EndEventId: rand.Int63(),
|
|
EndEventVersion: rand.Int63(),
|
|
}
|
|
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(resendErr.NamespaceId),
|
|
resendErr.WorkflowId,
|
|
resendErr.RunId,
|
|
resendErr.StartEventId,
|
|
resendErr.StartEventVersion,
|
|
resendErr.EndEventId,
|
|
resendErr.EndEventVersion,
|
|
).Return(serviceerror.NewNotFound(""))
|
|
shardContext := shard.NewMockContext(s.controller)
|
|
engine := shard.NewMockEngine(s.controller)
|
|
s.shardController.EXPECT().GetShardByNamespaceWorkflow(
|
|
namespace.ID(resendErr.NamespaceId),
|
|
resendErr.WorkflowId,
|
|
).Return(shardContext, nil).AnyTimes()
|
|
shardContext.EXPECT().GetEngine(gomock.Any()).Return(engine, nil).AnyTimes()
|
|
engine.EXPECT().DeleteWorkflowExecution(gomock.Any(), &historyservice.DeleteWorkflowExecutionRequest{
|
|
NamespaceId: resendErr.NamespaceId,
|
|
WorkflowExecution: &commonpb.WorkflowExecution{
|
|
WorkflowId: resendErr.WorkflowId,
|
|
RunId: resendErr.RunId,
|
|
},
|
|
WorkflowVersion: common.EmptyVersion,
|
|
ClosedWorkflowOnly: false,
|
|
}).Return(&historyservice.DeleteWorkflowExecutionResponse{}, nil)
|
|
|
|
doContinue, err := s.task.Resend(context.Background(), remoteCluster, resendErr, ResendAttempt)
|
|
s.NoError(err)
|
|
s.False(doContinue)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestResend_ResendError_Success() {
|
|
remoteCluster := cluster.TestAlternativeClusterName
|
|
resendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: uuid.NewString(),
|
|
WorkflowId: uuid.NewString(),
|
|
RunId: uuid.NewString(),
|
|
StartEventId: rand.Int63(),
|
|
StartEventVersion: rand.Int63(),
|
|
EndEventId: rand.Int63(),
|
|
EndEventVersion: rand.Int63(),
|
|
}
|
|
|
|
anotherResendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: resendErr.NamespaceId,
|
|
WorkflowId: resendErr.WorkflowId,
|
|
RunId: uuid.NewString(),
|
|
StartEventId: rand.Int63(),
|
|
StartEventVersion: rand.Int63(),
|
|
EndEventId: rand.Int63(),
|
|
EndEventVersion: rand.Int63(),
|
|
}
|
|
|
|
gomock.InOrder(
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(resendErr.NamespaceId),
|
|
resendErr.WorkflowId,
|
|
resendErr.RunId,
|
|
resendErr.StartEventId,
|
|
resendErr.StartEventVersion,
|
|
resendErr.EndEventId,
|
|
resendErr.EndEventVersion,
|
|
).Return(anotherResendErr),
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(anotherResendErr.NamespaceId),
|
|
anotherResendErr.WorkflowId,
|
|
anotherResendErr.RunId,
|
|
anotherResendErr.StartEventId,
|
|
anotherResendErr.StartEventVersion,
|
|
anotherResendErr.EndEventId,
|
|
anotherResendErr.EndEventVersion,
|
|
).Return(nil),
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(resendErr.NamespaceId),
|
|
resendErr.WorkflowId,
|
|
resendErr.RunId,
|
|
resendErr.StartEventId,
|
|
resendErr.StartEventVersion,
|
|
resendErr.EndEventId,
|
|
resendErr.EndEventVersion,
|
|
).Return(nil),
|
|
)
|
|
|
|
doContinue, err := s.task.Resend(context.Background(), remoteCluster, resendErr, ResendAttempt)
|
|
s.NoError(err)
|
|
s.True(doContinue)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestResend_ResendError_Error() {
|
|
remoteCluster := cluster.TestAlternativeClusterName
|
|
resendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: uuid.NewString(),
|
|
WorkflowId: uuid.NewString(),
|
|
RunId: uuid.NewString(),
|
|
StartEventId: rand.Int63(),
|
|
StartEventVersion: rand.Int63(),
|
|
EndEventId: rand.Int63(),
|
|
EndEventVersion: rand.Int63(),
|
|
}
|
|
|
|
anotherResendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: resendErr.NamespaceId,
|
|
WorkflowId: resendErr.WorkflowId,
|
|
RunId: uuid.NewString(),
|
|
StartEventId: rand.Int63(),
|
|
StartEventVersion: rand.Int63(),
|
|
EndEventId: rand.Int63(),
|
|
EndEventVersion: rand.Int63(),
|
|
}
|
|
|
|
gomock.InOrder(
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(resendErr.NamespaceId),
|
|
resendErr.WorkflowId,
|
|
resendErr.RunId,
|
|
resendErr.StartEventId,
|
|
resendErr.StartEventVersion,
|
|
resendErr.EndEventId,
|
|
resendErr.EndEventVersion,
|
|
).Return(anotherResendErr),
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(anotherResendErr.NamespaceId),
|
|
anotherResendErr.WorkflowId,
|
|
anotherResendErr.RunId,
|
|
anotherResendErr.StartEventId,
|
|
anotherResendErr.StartEventVersion,
|
|
anotherResendErr.EndEventId,
|
|
anotherResendErr.EndEventVersion,
|
|
).Return(&serviceerrors.RetryReplication{}),
|
|
)
|
|
|
|
doContinue, err := s.task.Resend(context.Background(), remoteCluster, resendErr, ResendAttempt)
|
|
s.Error(err)
|
|
s.False(doContinue)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestResend_SecondResendError_SameWorkflowRun() {
|
|
remoteCluster := cluster.TestAlternativeClusterName
|
|
resendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: uuid.NewString(),
|
|
WorkflowId: uuid.NewString(),
|
|
RunId: uuid.NewString(),
|
|
StartEventId: rand.Int63(),
|
|
StartEventVersion: rand.Int63(),
|
|
EndEventId: rand.Int63(),
|
|
EndEventVersion: rand.Int63(),
|
|
}
|
|
|
|
anotherResendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: resendErr.NamespaceId,
|
|
WorkflowId: resendErr.WorkflowId,
|
|
RunId: resendErr.RunId,
|
|
StartEventId: resendErr.StartEventId,
|
|
StartEventVersion: resendErr.StartEventVersion,
|
|
EndEventId: resendErr.EndEventId,
|
|
EndEventVersion: resendErr.EndEventVersion,
|
|
}
|
|
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(resendErr.NamespaceId),
|
|
resendErr.WorkflowId,
|
|
resendErr.RunId,
|
|
resendErr.StartEventId,
|
|
resendErr.StartEventVersion,
|
|
resendErr.EndEventId,
|
|
resendErr.EndEventVersion,
|
|
).Return(anotherResendErr)
|
|
|
|
doContinue, err := s.task.Resend(context.Background(), remoteCluster, resendErr, ResendAttempt)
|
|
var dataLossErr *serviceerror.DataLoss
|
|
s.ErrorAs(err, &dataLossErr)
|
|
s.False(doContinue)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestResend_Error() {
|
|
remoteCluster := cluster.TestAlternativeClusterName
|
|
resendErr := &serviceerrors.RetryReplication{
|
|
NamespaceId: uuid.NewString(),
|
|
WorkflowId: uuid.NewString(),
|
|
RunId: uuid.NewString(),
|
|
StartEventId: rand.Int63(),
|
|
StartEventVersion: rand.Int63(),
|
|
EndEventId: rand.Int63(),
|
|
EndEventVersion: rand.Int63(),
|
|
}
|
|
|
|
s.ndcHistoryResender.EXPECT().SendSingleWorkflowHistory(
|
|
gomock.Any(),
|
|
remoteCluster,
|
|
namespace.ID(resendErr.NamespaceId),
|
|
resendErr.WorkflowId,
|
|
resendErr.RunId,
|
|
resendErr.StartEventId,
|
|
resendErr.StartEventVersion,
|
|
resendErr.EndEventId,
|
|
resendErr.EndEventVersion,
|
|
).Return(serviceerror.NewUnavailable(""))
|
|
|
|
doContinue, err := s.task.Resend(context.Background(), remoteCluster, resendErr, ResendAttempt)
|
|
s.Error(err)
|
|
s.False(doContinue)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestGetNamespaceInfo_Process() {
|
|
namespaceID := uuid.NewString()
|
|
namespaceName := uuid.NewString()
|
|
namespaceEntry := namespace.FromPersistentState(&persistence.GetNamespaceResponse{
|
|
Namespace: &persistencespb.NamespaceDetail{
|
|
Info: &persistencespb.NamespaceInfo{
|
|
Id: namespaceID,
|
|
Name: namespaceName,
|
|
},
|
|
Config: &persistencespb.NamespaceConfig{},
|
|
ReplicationConfig: &persistencespb.NamespaceReplicationConfig{
|
|
ActiveClusterName: cluster.TestAlternativeClusterName,
|
|
Clusters: []string{
|
|
cluster.TestCurrentClusterName,
|
|
cluster.TestAlternativeClusterName,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
s.namespaceCache.EXPECT().GetNamespaceByID(namespace.ID(namespaceID)).Return(namespaceEntry, nil).AnyTimes()
|
|
s.clusterMetadata.EXPECT().GetCurrentClusterName().Return(cluster.TestCurrentClusterName).AnyTimes()
|
|
|
|
name, toProcess, err := s.task.GetNamespaceInfo(context.Background(), namespaceID)
|
|
s.NoError(err)
|
|
s.Equal(namespaceName, name)
|
|
s.True(toProcess)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestGetNamespaceInfo_Skip() {
|
|
namespaceID := uuid.NewString()
|
|
namespaceName := uuid.NewString()
|
|
namespaceEntry := namespace.FromPersistentState(&persistence.GetNamespaceResponse{
|
|
Namespace: &persistencespb.NamespaceDetail{
|
|
Info: &persistencespb.NamespaceInfo{
|
|
Id: namespaceID,
|
|
Name: namespaceName,
|
|
},
|
|
Config: &persistencespb.NamespaceConfig{},
|
|
ReplicationConfig: &persistencespb.NamespaceReplicationConfig{
|
|
ActiveClusterName: cluster.TestAlternativeClusterName,
|
|
Clusters: []string{
|
|
cluster.TestAlternativeClusterName,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
s.namespaceCache.EXPECT().GetNamespaceByID(namespace.ID(namespaceID)).Return(namespaceEntry, nil).AnyTimes()
|
|
s.clusterMetadata.EXPECT().GetCurrentClusterName().Return(cluster.TestCurrentClusterName).AnyTimes()
|
|
|
|
name, toProcess, err := s.task.GetNamespaceInfo(context.Background(), namespaceID)
|
|
s.NoError(err)
|
|
s.Equal(namespaceName, name)
|
|
s.False(toProcess)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestGetNamespaceInfo_Error() {
|
|
namespaceID := uuid.NewString()
|
|
s.namespaceCache.EXPECT().GetNamespaceByID(namespace.ID(namespaceID)).Return(nil, errors.New("OwO")).AnyTimes()
|
|
s.clusterMetadata.EXPECT().GetCurrentClusterName().Return(cluster.TestCurrentClusterName).AnyTimes()
|
|
|
|
_, _, err := s.task.GetNamespaceInfo(context.Background(), namespaceID)
|
|
s.Error(err)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestGetNamespaceInfo_NotFoundOnCurrentCluster_SyncFromRemoteSuccess() {
|
|
namespaceID := uuid.NewString()
|
|
namespaceName := uuid.NewString()
|
|
namespaceEntry := namespace.FromPersistentState(&persistence.GetNamespaceResponse{
|
|
Namespace: &persistencespb.NamespaceDetail{
|
|
Info: &persistencespb.NamespaceInfo{
|
|
Id: namespaceID,
|
|
Name: namespaceName,
|
|
},
|
|
Config: &persistencespb.NamespaceConfig{},
|
|
ReplicationConfig: &persistencespb.NamespaceReplicationConfig{
|
|
ActiveClusterName: cluster.TestAlternativeClusterName,
|
|
Clusters: []string{
|
|
cluster.TestCurrentClusterName,
|
|
cluster.TestAlternativeClusterName,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
// enable feature flag
|
|
s.config.EnableReplicationEagerRefreshNamespace = dynamicconfig.GetBoolPropertyFn(true)
|
|
|
|
s.namespaceCache.EXPECT().GetNamespaceByID(namespace.ID(namespaceID)).Return(nil, serviceerror.NewNamespaceNotFound("namespace not found")).AnyTimes()
|
|
s.eagerNamespaceRefresher.EXPECT().SyncNamespaceFromSourceCluster(gomock.Any(), namespace.ID(namespaceID), gomock.Any()).Return(
|
|
namespaceEntry, nil)
|
|
s.clusterMetadata.EXPECT().GetCurrentClusterName().Return(cluster.TestCurrentClusterName).AnyTimes()
|
|
|
|
name, toProcess, err := s.task.GetNamespaceInfo(context.Background(), namespaceID)
|
|
s.NoError(err)
|
|
s.Equal(namespaceName, name)
|
|
s.True(toProcess)
|
|
}
|
|
|
|
func (s *executableTaskSuite) TestGetNamespaceInfo_NotFoundOnCurrentCluster_SyncFromRemoteFailed() {
|
|
namespaceID := uuid.NewString()
|
|
|
|
// Enable feature flag
|
|
s.config.EnableReplicationEagerRefreshNamespace = dynamicconfig.GetBoolPropertyFn(true)
|
|
s.namespaceCache.EXPECT().GetNamespaceByID(namespace.ID(namespaceID)).Return(nil, serviceerror.NewNamespaceNotFound("namespace not found")).AnyTimes()
|
|
s.eagerNamespaceRefresher.EXPECT().SyncNamespaceFromSourceCluster(gomock.Any(), namespace.ID(namespaceID), gomock.Any()).Return(
|
|
nil, errors.New("some error"))
|
|
s.clusterMetadata.EXPECT().GetCurrentClusterName().Return(cluster.TestCurrentClusterName).AnyTimes()
|
|
|
|
_, toProcess, err := s.task.GetNamespaceInfo(context.Background(), namespaceID)
|
|
s.Nil(err)
|
|
s.False(toProcess)
|
|
}
|