go.temporal.io/server@v1.23.0/common/namespace/transmission_task_handler_test.go (about)

     1  // The MIT License
     2  //
     3  // Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
     4  //
     5  // Copyright (c) 2020 Uber Technologies, Inc.
     6  //
     7  // Permission is hereby granted, free of charge, to any person obtaining a copy
     8  // of this software and associated documentation files (the "Software"), to deal
     9  // in the Software without restriction, including without limitation the rights
    10  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    11  // copies of the Software, and to permit persons to whom the Software is
    12  // furnished to do so, subject to the following conditions:
    13  //
    14  // The above copyright notice and this permission notice shall be included in
    15  // all copies or substantial portions of the Software.
    16  //
    17  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    18  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    19  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    20  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    21  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    22  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    23  // THE SOFTWARE.
    24  
    25  package namespace
    26  
    27  import (
    28  	"context"
    29  	"testing"
    30  	"time"
    31  
    32  	"github.com/golang/mock/gomock"
    33  	"github.com/stretchr/testify/suite"
    34  	enumspb "go.temporal.io/api/enums/v1"
    35  	namespacepb "go.temporal.io/api/namespace/v1"
    36  	replicationpb "go.temporal.io/api/replication/v1"
    37  	"google.golang.org/protobuf/types/known/durationpb"
    38  
    39  	enumsspb "go.temporal.io/server/api/enums/v1"
    40  	persistencespb "go.temporal.io/server/api/persistence/v1"
    41  	replicationspb "go.temporal.io/server/api/replication/v1"
    42  	"go.temporal.io/server/common/log"
    43  	"go.temporal.io/server/common/persistence"
    44  	"go.temporal.io/server/common/primitives"
    45  )
    46  
    47  type (
    48  	transmissionTaskSuite struct {
    49  		suite.Suite
    50  
    51  		controller *gomock.Controller
    52  
    53  		namespaceReplicator       *namespaceReplicatorImpl
    54  		namespaceReplicationQueue *persistence.MockNamespaceReplicationQueue
    55  	}
    56  )
    57  
    58  func TestTransmissionTaskSuite(t *testing.T) {
    59  	s := new(transmissionTaskSuite)
    60  	suite.Run(t, s)
    61  }
    62  
    63  func (s *transmissionTaskSuite) SetupSuite() {
    64  }
    65  
    66  func (s *transmissionTaskSuite) TearDownSuite() {
    67  
    68  }
    69  
    70  func (s *transmissionTaskSuite) SetupTest() {
    71  	s.controller = gomock.NewController(s.T())
    72  	s.namespaceReplicationQueue = persistence.NewMockNamespaceReplicationQueue(s.controller)
    73  	s.namespaceReplicator = NewNamespaceReplicator(
    74  		s.namespaceReplicationQueue,
    75  		log.NewTestLogger(),
    76  	).(*namespaceReplicatorImpl)
    77  }
    78  
    79  func (s *transmissionTaskSuite) TearDownTest() {
    80  	s.controller.Finish()
    81  }
    82  
    83  func (s *transmissionTaskSuite) TestHandleTransmissionTask_RegisterNamespaceTask_IsGlobalNamespace() {
    84  	taskType := enumsspb.REPLICATION_TASK_TYPE_NAMESPACE_TASK
    85  	id := primitives.NewUUID().String()
    86  	name := "some random namespace test name"
    87  	state := enumspb.NAMESPACE_STATE_REGISTERED
    88  	description := "some random test description"
    89  	ownerEmail := "some random test owner"
    90  	data := map[string]string{"k": "v"}
    91  	retention := 10 * time.Hour * 24
    92  	historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
    93  	historyArchivalURI := "some random history archival uri"
    94  	visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
    95  	visibilityArchivalURI := "some random visibility archival uri"
    96  	clusterActive := "some random active cluster name"
    97  	clusterStandby := "some random standby cluster name"
    98  	configVersion := int64(0)
    99  	failoverVersion := int64(59)
   100  	clusters := []string{clusterActive, clusterStandby}
   101  
   102  	namespaceOperation := enumsspb.NAMESPACE_OPERATION_CREATE
   103  	info := &persistencespb.NamespaceInfo{
   104  		Id:          id,
   105  		Name:        name,
   106  		State:       enumspb.NAMESPACE_STATE_REGISTERED,
   107  		Description: description,
   108  		Owner:       ownerEmail,
   109  		Data:        data,
   110  	}
   111  	config := &persistencespb.NamespaceConfig{
   112  		Retention:               durationpb.New(retention),
   113  		HistoryArchivalState:    historyArchivalState,
   114  		HistoryArchivalUri:      historyArchivalURI,
   115  		VisibilityArchivalState: visibilityArchivalState,
   116  		VisibilityArchivalUri:   visibilityArchivalURI,
   117  		BadBinaries:             &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}},
   118  	}
   119  	replicationConfig := &persistencespb.NamespaceReplicationConfig{
   120  		ActiveClusterName: clusterActive,
   121  		Clusters:          clusters,
   122  	}
   123  	isGlobalNamespace := true
   124  
   125  	s.namespaceReplicationQueue.EXPECT().Publish(gomock.Any(), &replicationspb.ReplicationTask{
   126  		TaskType: taskType,
   127  		Attributes: &replicationspb.ReplicationTask_NamespaceTaskAttributes{
   128  			NamespaceTaskAttributes: &replicationspb.NamespaceTaskAttributes{
   129  				NamespaceOperation: namespaceOperation,
   130  				Id:                 id,
   131  				Info: &namespacepb.NamespaceInfo{
   132  					Name:        name,
   133  					State:       state,
   134  					Description: description,
   135  					OwnerEmail:  ownerEmail,
   136  					Data:        data,
   137  				},
   138  				Config: &namespacepb.NamespaceConfig{
   139  					WorkflowExecutionRetentionTtl: durationpb.New(retention),
   140  					HistoryArchivalState:          historyArchivalState,
   141  					HistoryArchivalUri:            historyArchivalURI,
   142  					VisibilityArchivalState:       visibilityArchivalState,
   143  					VisibilityArchivalUri:         visibilityArchivalURI,
   144  					BadBinaries:                   &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}},
   145  				},
   146  				ReplicationConfig: &replicationpb.NamespaceReplicationConfig{
   147  					ActiveClusterName: clusterActive,
   148  					Clusters:          convertClusterReplicationConfigToProto(clusters),
   149  				},
   150  				ConfigVersion:   configVersion,
   151  				FailoverVersion: failoverVersion,
   152  			},
   153  		},
   154  	}).Return(nil)
   155  
   156  	err := s.namespaceReplicator.HandleTransmissionTask(
   157  		context.Background(),
   158  		namespaceOperation,
   159  		info,
   160  		config,
   161  		replicationConfig,
   162  		true,
   163  		configVersion,
   164  		failoverVersion,
   165  		isGlobalNamespace,
   166  		nil,
   167  	)
   168  	s.Nil(err)
   169  }
   170  
   171  func (s *transmissionTaskSuite) TestHandleTransmissionTask_RegisterNamespaceTask_NotGlobalNamespace() {
   172  	id := primitives.NewUUID().String()
   173  	name := "some random namespace test name"
   174  	description := "some random test description"
   175  	ownerEmail := "some random test owner"
   176  	data := map[string]string{"k": "v"}
   177  	retention := 10 * time.Hour * 24
   178  	historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
   179  	historyArchivalURI := "some random history archival uri"
   180  	visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
   181  	visibilityArchivalURI := "some random visibility archival uri"
   182  	clusterActive := "some random active cluster name"
   183  	clusterStandby := "some random standby cluster name"
   184  	configVersion := int64(0)
   185  	failoverVersion := int64(59)
   186  	clusters := []string{clusterActive, clusterStandby}
   187  
   188  	namespaceOperation := enumsspb.NAMESPACE_OPERATION_CREATE
   189  	info := &persistencespb.NamespaceInfo{
   190  		Id:          id,
   191  		Name:        name,
   192  		State:       enumspb.NAMESPACE_STATE_REGISTERED,
   193  		Description: description,
   194  		Owner:       ownerEmail,
   195  		Data:        data,
   196  	}
   197  	config := &persistencespb.NamespaceConfig{
   198  		Retention:               durationpb.New(retention),
   199  		HistoryArchivalState:    historyArchivalState,
   200  		HistoryArchivalUri:      historyArchivalURI,
   201  		VisibilityArchivalState: visibilityArchivalState,
   202  		VisibilityArchivalUri:   visibilityArchivalURI,
   203  		BadBinaries:             &namespacepb.BadBinaries{},
   204  	}
   205  	replicationConfig := &persistencespb.NamespaceReplicationConfig{
   206  		ActiveClusterName: clusterActive,
   207  		Clusters:          clusters,
   208  	}
   209  	isGlobalNamespace := false
   210  
   211  	err := s.namespaceReplicator.HandleTransmissionTask(
   212  		context.Background(),
   213  		namespaceOperation,
   214  		info,
   215  		config,
   216  		replicationConfig,
   217  		true,
   218  		configVersion,
   219  		failoverVersion,
   220  		isGlobalNamespace,
   221  		nil,
   222  	)
   223  	s.Nil(err)
   224  }
   225  
   226  func (s *transmissionTaskSuite) TestHandleTransmissionTask_UpdateNamespaceTask_IsGlobalNamespace() {
   227  	taskType := enumsspb.REPLICATION_TASK_TYPE_NAMESPACE_TASK
   228  	id := primitives.NewUUID().String()
   229  	name := "some random namespace test name"
   230  	state := enumspb.NAMESPACE_STATE_DEPRECATED
   231  	description := "some random test description"
   232  	ownerEmail := "some random test owner"
   233  	data := map[string]string{"k": "v"}
   234  	retention := 10 * time.Hour * 24
   235  	historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
   236  	historyArchivalURI := "some random history archival uri"
   237  	visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
   238  	visibilityArchivalURI := "some random visibility archival uri"
   239  	clusterActive := "some random active cluster name"
   240  	clusterStandby := "some random standby cluster name"
   241  	configVersion := int64(0)
   242  	failoverVersion := int64(59)
   243  	clusters := []string{clusterActive, clusterStandby}
   244  
   245  	namespaceOperation := enumsspb.NAMESPACE_OPERATION_UPDATE
   246  	info := &persistencespb.NamespaceInfo{
   247  		Id:          id,
   248  		Name:        name,
   249  		State:       enumspb.NAMESPACE_STATE_DEPRECATED,
   250  		Description: description,
   251  		Owner:       ownerEmail,
   252  		Data:        data,
   253  	}
   254  	config := &persistencespb.NamespaceConfig{
   255  		Retention:               durationpb.New(retention),
   256  		HistoryArchivalState:    historyArchivalState,
   257  		HistoryArchivalUri:      historyArchivalURI,
   258  		VisibilityArchivalState: visibilityArchivalState,
   259  		VisibilityArchivalUri:   visibilityArchivalURI,
   260  		BadBinaries:             &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}},
   261  	}
   262  	replicationConfig := &persistencespb.NamespaceReplicationConfig{
   263  		ActiveClusterName: clusterActive,
   264  		Clusters:          clusters,
   265  	}
   266  	isGlobalNamespace := true
   267  
   268  	s.namespaceReplicationQueue.EXPECT().Publish(gomock.Any(), &replicationspb.ReplicationTask{
   269  		TaskType: taskType,
   270  		Attributes: &replicationspb.ReplicationTask_NamespaceTaskAttributes{
   271  			NamespaceTaskAttributes: &replicationspb.NamespaceTaskAttributes{
   272  				NamespaceOperation: namespaceOperation,
   273  				Id:                 id,
   274  				Info: &namespacepb.NamespaceInfo{
   275  					Name:        name,
   276  					State:       state,
   277  					Description: description,
   278  					OwnerEmail:  ownerEmail,
   279  					Data:        data,
   280  				},
   281  				Config: &namespacepb.NamespaceConfig{
   282  					WorkflowExecutionRetentionTtl: durationpb.New(retention),
   283  					HistoryArchivalState:          historyArchivalState,
   284  					HistoryArchivalUri:            historyArchivalURI,
   285  					VisibilityArchivalState:       visibilityArchivalState,
   286  					VisibilityArchivalUri:         visibilityArchivalURI,
   287  					BadBinaries:                   &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}},
   288  				},
   289  				ReplicationConfig: &replicationpb.NamespaceReplicationConfig{
   290  					ActiveClusterName: clusterActive,
   291  					Clusters:          convertClusterReplicationConfigToProto(clusters),
   292  				},
   293  				ConfigVersion:   configVersion,
   294  				FailoverVersion: failoverVersion},
   295  		},
   296  	}).Return(nil)
   297  
   298  	err := s.namespaceReplicator.HandleTransmissionTask(
   299  		context.Background(),
   300  		namespaceOperation,
   301  		info,
   302  		config,
   303  		replicationConfig,
   304  		true,
   305  		configVersion,
   306  		failoverVersion,
   307  		isGlobalNamespace,
   308  		nil,
   309  	)
   310  	s.Nil(err)
   311  }
   312  
   313  func (s *transmissionTaskSuite) TestHandleTransmissionTask_UpdateNamespaceTask_NotGlobalNamespace() {
   314  	id := primitives.NewUUID().String()
   315  	name := "some random namespace test name"
   316  	description := "some random test description"
   317  	ownerEmail := "some random test owner"
   318  	data := map[string]string{"k": "v"}
   319  	retention := 10 * time.Hour * 24
   320  	historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
   321  	historyArchivalURI := "some random history archival uri"
   322  	visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
   323  	visibilityArchivalURI := "some random visibility archival uri"
   324  	clusterActive := "some random active cluster name"
   325  	clusterStandby := "some random standby cluster name"
   326  	configVersion := int64(0)
   327  	failoverVersion := int64(59)
   328  	clusters := []string{clusterActive, clusterStandby}
   329  
   330  	namespaceOperation := enumsspb.NAMESPACE_OPERATION_UPDATE
   331  	info := &persistencespb.NamespaceInfo{
   332  		Id:          id,
   333  		Name:        name,
   334  		State:       enumspb.NAMESPACE_STATE_DEPRECATED,
   335  		Description: description,
   336  		Owner:       ownerEmail,
   337  		Data:        data,
   338  	}
   339  	config := &persistencespb.NamespaceConfig{
   340  		Retention:               durationpb.New(retention),
   341  		HistoryArchivalState:    historyArchivalState,
   342  		HistoryArchivalUri:      historyArchivalURI,
   343  		VisibilityArchivalState: visibilityArchivalState,
   344  		VisibilityArchivalUri:   visibilityArchivalURI,
   345  	}
   346  	replicationConfig := &persistencespb.NamespaceReplicationConfig{
   347  		ActiveClusterName: clusterActive,
   348  		Clusters:          clusters,
   349  	}
   350  	isGlobalNamespace := false
   351  
   352  	err := s.namespaceReplicator.HandleTransmissionTask(
   353  		context.Background(),
   354  		namespaceOperation,
   355  		info,
   356  		config,
   357  		replicationConfig,
   358  		true,
   359  		configVersion,
   360  		failoverVersion,
   361  		isGlobalNamespace,
   362  		nil,
   363  	)
   364  	s.Nil(err)
   365  }
   366  
   367  func (s *transmissionTaskSuite) TestHandleTransmissionTask_UpdateNamespaceTask_ReplicationClusterListUpdated() {
   368  	taskType := enumsspb.REPLICATION_TASK_TYPE_NAMESPACE_TASK
   369  	id := primitives.NewUUID().String()
   370  	name := "some random namespace test name"
   371  	state := enumspb.NAMESPACE_STATE_DEPRECATED
   372  	description := "some random test description"
   373  	ownerEmail := "some random test owner"
   374  	data := map[string]string{"k": "v"}
   375  	retention := 10 * time.Hour * 24
   376  	historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
   377  	historyArchivalURI := "some random history archival uri"
   378  	visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED
   379  	visibilityArchivalURI := "some random visibility archival uri"
   380  	clusterActive := "some random active cluster name"
   381  	configVersion := int64(0)
   382  	failoverVersion := int64(59)
   383  	singleClusterList := []string{clusterActive}
   384  
   385  	namespaceOperation := enumsspb.NAMESPACE_OPERATION_UPDATE
   386  	info := &persistencespb.NamespaceInfo{
   387  		Id:          id,
   388  		Name:        name,
   389  		State:       enumspb.NAMESPACE_STATE_DEPRECATED,
   390  		Description: description,
   391  		Owner:       ownerEmail,
   392  		Data:        data,
   393  	}
   394  	config := &persistencespb.NamespaceConfig{
   395  		Retention:               durationpb.New(retention),
   396  		HistoryArchivalState:    historyArchivalState,
   397  		HistoryArchivalUri:      historyArchivalURI,
   398  		VisibilityArchivalState: visibilityArchivalState,
   399  		VisibilityArchivalUri:   visibilityArchivalURI,
   400  		BadBinaries:             &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}},
   401  	}
   402  	replicationConfig := &persistencespb.NamespaceReplicationConfig{
   403  		ActiveClusterName: clusterActive,
   404  		Clusters:          singleClusterList,
   405  	}
   406  
   407  	isGlobalNamespace := true
   408  
   409  	s.namespaceReplicationQueue.EXPECT().Publish(gomock.Any(), &replicationspb.ReplicationTask{
   410  		TaskType: taskType,
   411  		Attributes: &replicationspb.ReplicationTask_NamespaceTaskAttributes{
   412  			NamespaceTaskAttributes: &replicationspb.NamespaceTaskAttributes{
   413  				NamespaceOperation: namespaceOperation,
   414  				Id:                 id,
   415  				Info: &namespacepb.NamespaceInfo{
   416  					Name:        name,
   417  					State:       state,
   418  					Description: description,
   419  					OwnerEmail:  ownerEmail,
   420  					Data:        data,
   421  				},
   422  				Config: &namespacepb.NamespaceConfig{
   423  					WorkflowExecutionRetentionTtl: durationpb.New(retention),
   424  					HistoryArchivalState:          historyArchivalState,
   425  					HistoryArchivalUri:            historyArchivalURI,
   426  					VisibilityArchivalState:       visibilityArchivalState,
   427  					VisibilityArchivalUri:         visibilityArchivalURI,
   428  					BadBinaries:                   &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}},
   429  				},
   430  				ReplicationConfig: &replicationpb.NamespaceReplicationConfig{
   431  					ActiveClusterName: clusterActive,
   432  					Clusters:          convertClusterReplicationConfigToProto(singleClusterList),
   433  				},
   434  				ConfigVersion:   configVersion,
   435  				FailoverVersion: failoverVersion},
   436  		},
   437  	}).Return(nil).Times(1)
   438  
   439  	err := s.namespaceReplicator.HandleTransmissionTask(
   440  		context.Background(),
   441  		namespaceOperation,
   442  		info,
   443  		config,
   444  		replicationConfig,
   445  		true,
   446  		configVersion,
   447  		failoverVersion,
   448  		isGlobalNamespace,
   449  		nil,
   450  	)
   451  	s.Nil(err)
   452  
   453  	err = s.namespaceReplicator.HandleTransmissionTask(
   454  		context.Background(),
   455  		namespaceOperation,
   456  		info,
   457  		config,
   458  		replicationConfig,
   459  		false,
   460  		configVersion,
   461  		failoverVersion,
   462  		isGlobalNamespace,
   463  		nil,
   464  	)
   465  	s.Nil(err)
   466  }