go.temporal.io/server@v1.23.0/common/persistence/metadata_manager.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 persistence
    26  
    27  import (
    28  	"context"
    29  
    30  	enumspb "go.temporal.io/api/enums/v1"
    31  	namespacepb "go.temporal.io/api/namespace/v1"
    32  	"go.temporal.io/api/serviceerror"
    33  	"google.golang.org/protobuf/types/known/durationpb"
    34  
    35  	persistencespb "go.temporal.io/server/api/persistence/v1"
    36  	"go.temporal.io/server/common"
    37  	"go.temporal.io/server/common/log"
    38  	"go.temporal.io/server/common/persistence/serialization"
    39  	"go.temporal.io/server/common/primitives"
    40  )
    41  
    42  type (
    43  
    44  	// metadataManagerImpl implements MetadataManager based on MetadataStore and Serializer
    45  	metadataManagerImpl struct {
    46  		serializer  serialization.Serializer
    47  		persistence MetadataStore
    48  		logger      log.Logger
    49  		clusterName string
    50  	}
    51  )
    52  
    53  var _ MetadataManager = (*metadataManagerImpl)(nil)
    54  
    55  // NewMetadataManagerImpl returns new MetadataManager
    56  func NewMetadataManagerImpl(
    57  	persistence MetadataStore,
    58  	serializer serialization.Serializer,
    59  	logger log.Logger,
    60  	clusterName string,
    61  ) MetadataManager {
    62  	return &metadataManagerImpl{
    63  		serializer:  serializer,
    64  		persistence: persistence,
    65  		logger:      logger,
    66  		clusterName: clusterName,
    67  	}
    68  }
    69  
    70  func (m *metadataManagerImpl) GetName() string {
    71  	return m.persistence.GetName()
    72  }
    73  
    74  func (m *metadataManagerImpl) CreateNamespace(
    75  	ctx context.Context,
    76  	request *CreateNamespaceRequest,
    77  ) (*CreateNamespaceResponse, error) {
    78  	datablob, err := m.serializer.NamespaceDetailToBlob(request.Namespace, enumspb.ENCODING_TYPE_PROTO3)
    79  	if err != nil {
    80  		return nil, err
    81  	}
    82  
    83  	return m.persistence.CreateNamespace(ctx, &InternalCreateNamespaceRequest{
    84  		ID:        request.Namespace.Info.Id,
    85  		Name:      request.Namespace.Info.Name,
    86  		IsGlobal:  request.IsGlobalNamespace,
    87  		Namespace: datablob,
    88  	})
    89  }
    90  
    91  func (m *metadataManagerImpl) GetNamespace(
    92  	ctx context.Context,
    93  	request *GetNamespaceRequest,
    94  ) (*GetNamespaceResponse, error) {
    95  	resp, err := m.persistence.GetNamespace(ctx, request)
    96  	if err != nil {
    97  		return nil, err
    98  	}
    99  	return m.ConvertInternalGetResponse(resp)
   100  }
   101  
   102  func (m *metadataManagerImpl) UpdateNamespace(
   103  	ctx context.Context,
   104  	request *UpdateNamespaceRequest,
   105  ) error {
   106  	datablob, err := m.serializer.NamespaceDetailToBlob(request.Namespace, enumspb.ENCODING_TYPE_PROTO3)
   107  	if err != nil {
   108  		return err
   109  	}
   110  
   111  	return m.persistence.UpdateNamespace(ctx, &InternalUpdateNamespaceRequest{
   112  		Id:                  request.Namespace.Info.Id,
   113  		Name:                request.Namespace.Info.Name,
   114  		Namespace:           datablob,
   115  		NotificationVersion: request.NotificationVersion,
   116  		IsGlobal:            request.IsGlobalNamespace,
   117  	})
   118  }
   119  
   120  func (m *metadataManagerImpl) RenameNamespace(
   121  	ctx context.Context,
   122  	request *RenameNamespaceRequest,
   123  ) error {
   124  	ns, err := m.GetNamespace(ctx, &GetNamespaceRequest{
   125  		Name: request.PreviousName,
   126  	})
   127  	if err != nil {
   128  		return err
   129  	}
   130  
   131  	metadata, err := m.GetMetadata(ctx)
   132  	if err != nil {
   133  		return err
   134  	}
   135  
   136  	previousName := ns.Namespace.Info.Name
   137  	ns.Namespace.Info.Name = request.NewName
   138  
   139  	nsDataBlob, err := m.serializer.NamespaceDetailToBlob(ns.Namespace, enumspb.ENCODING_TYPE_PROTO3)
   140  	if err != nil {
   141  		return err
   142  	}
   143  
   144  	renameRequest := &InternalRenameNamespaceRequest{
   145  		InternalUpdateNamespaceRequest: &InternalUpdateNamespaceRequest{
   146  			Id:                  ns.Namespace.Info.Id,
   147  			Name:                ns.Namespace.Info.Name,
   148  			Namespace:           nsDataBlob,
   149  			NotificationVersion: metadata.NotificationVersion,
   150  			IsGlobal:            ns.IsGlobalNamespace,
   151  		},
   152  		PreviousName: previousName,
   153  	}
   154  
   155  	return m.persistence.RenameNamespace(ctx, renameRequest)
   156  }
   157  
   158  func (m *metadataManagerImpl) DeleteNamespace(
   159  	ctx context.Context,
   160  	request *DeleteNamespaceRequest,
   161  ) error {
   162  	return m.persistence.DeleteNamespace(ctx, request)
   163  }
   164  
   165  func (m *metadataManagerImpl) DeleteNamespaceByName(
   166  	ctx context.Context,
   167  	request *DeleteNamespaceByNameRequest,
   168  ) error {
   169  	return m.persistence.DeleteNamespaceByName(ctx, request)
   170  }
   171  
   172  func (m *metadataManagerImpl) ConvertInternalGetResponse(d *InternalGetNamespaceResponse) (*GetNamespaceResponse, error) {
   173  	ns, err := m.serializer.NamespaceDetailFromBlob(d.Namespace)
   174  	if err != nil {
   175  		return nil, err
   176  	}
   177  
   178  	if ns.Info.Data == nil {
   179  		ns.Info.Data = map[string]string{}
   180  	}
   181  
   182  	if ns.Config.BadBinaries == nil || ns.Config.BadBinaries.Binaries == nil {
   183  		ns.Config.BadBinaries = &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}}
   184  	}
   185  
   186  	ns.ReplicationConfig.ActiveClusterName = GetOrUseDefaultActiveCluster(m.clusterName, ns.ReplicationConfig.ActiveClusterName)
   187  	ns.ReplicationConfig.Clusters = GetOrUseDefaultClusters(m.clusterName, ns.ReplicationConfig.Clusters)
   188  	return &GetNamespaceResponse{
   189  		Namespace:           ns,
   190  		IsGlobalNamespace:   d.IsGlobal,
   191  		NotificationVersion: d.NotificationVersion,
   192  	}, nil
   193  }
   194  
   195  func (m *metadataManagerImpl) ListNamespaces(
   196  	ctx context.Context,
   197  	request *ListNamespacesRequest,
   198  ) (*ListNamespacesResponse, error) {
   199  	var namespaces []*GetNamespaceResponse
   200  	nextPageToken := request.NextPageToken
   201  	pageSize := request.PageSize
   202  
   203  	for {
   204  		resp, err := m.persistence.ListNamespaces(ctx, &InternalListNamespacesRequest{
   205  			PageSize:      pageSize,
   206  			NextPageToken: nextPageToken,
   207  		})
   208  		if err != nil {
   209  			return nil, err
   210  		}
   211  		deletedNamespacesCount := 0
   212  		for _, d := range resp.Namespaces {
   213  			ret, err := m.ConvertInternalGetResponse(d)
   214  			if err != nil {
   215  				return nil, err
   216  			}
   217  			if ret.Namespace.Info.State == enumspb.NAMESPACE_STATE_DELETED && !request.IncludeDeleted {
   218  				deletedNamespacesCount++
   219  				continue
   220  			}
   221  			namespaces = append(namespaces, ret)
   222  		}
   223  		nextPageToken = resp.NextPageToken
   224  		if len(nextPageToken) == 0 {
   225  			// Page wasn't full, no more namespaces in DB.
   226  			break
   227  		}
   228  		if deletedNamespacesCount == 0 {
   229  			break
   230  		}
   231  		// Page was full but few namespaces weren't added. Read number of deleted namespaces for DB again.
   232  		pageSize = deletedNamespacesCount
   233  	}
   234  
   235  	return &ListNamespacesResponse{
   236  		Namespaces:    namespaces,
   237  		NextPageToken: nextPageToken,
   238  	}, nil
   239  }
   240  
   241  func (m *metadataManagerImpl) InitializeSystemNamespaces(
   242  	ctx context.Context,
   243  	currentClusterName string,
   244  ) error {
   245  	_, err := m.CreateNamespace(ctx, &CreateNamespaceRequest{
   246  		Namespace: &persistencespb.NamespaceDetail{
   247  			Info: &persistencespb.NamespaceInfo{
   248  				Id:          primitives.SystemNamespaceID,
   249  				Name:        primitives.SystemLocalNamespace,
   250  				State:       enumspb.NAMESPACE_STATE_REGISTERED,
   251  				Description: "Temporal internal system namespace",
   252  				Owner:       "temporal-core@temporal.io",
   253  			},
   254  			Config: &persistencespb.NamespaceConfig{
   255  				Retention:               durationpb.New(primitives.SystemNamespaceRetention),
   256  				HistoryArchivalState:    enumspb.ARCHIVAL_STATE_DISABLED,
   257  				VisibilityArchivalState: enumspb.ARCHIVAL_STATE_DISABLED,
   258  			},
   259  			ReplicationConfig: &persistencespb.NamespaceReplicationConfig{
   260  				ActiveClusterName: currentClusterName,
   261  				Clusters:          GetOrUseDefaultClusters(currentClusterName, nil),
   262  			},
   263  			FailoverVersion:             common.EmptyVersion,
   264  			FailoverNotificationVersion: -1,
   265  		},
   266  		IsGlobalNamespace: false,
   267  	})
   268  
   269  	if err != nil {
   270  		if _, ok := err.(*serviceerror.NamespaceAlreadyExists); !ok {
   271  			return err
   272  		}
   273  	}
   274  	return nil
   275  }
   276  
   277  func (m *metadataManagerImpl) GetMetadata(
   278  	ctx context.Context,
   279  ) (*GetMetadataResponse, error) {
   280  	return m.persistence.GetMetadata(ctx)
   281  }
   282  
   283  func (m *metadataManagerImpl) Close() {
   284  	m.persistence.Close()
   285  }