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 }