From 4019cd7e7bb832d8039b17f069222a3c6175944b Mon Sep 17 00:00:00 2001 From: yoshi-automation Date: Fri, 5 Mar 2021 08:45:14 -0800 Subject: [PATCH] feat: Publish Dataproc Metastore v1alpha API PiperOrigin-RevId: 361084441 Source-Author: Google APIs Source-Date: Thu Mar 4 23:41:25 2021 -0800 Source-Repo: googleapis/googleapis Source-Sha: 8f117308d5bb55816953a0d6ad1a7d27a69a7d3f Source-Link: https://github.com/googleapis/googleapis/commit/8f117308d5bb55816953a0d6ad1a7d27a69a7d3f --- .../DataprocMetastoreClientSnippets.g.cs | 1013 ++ .../DataprocMetastoreClientTest.g.cs | 192 +- .../DataprocMetastoreClient.g.cs | 1499 ++- .../Metastore.cs | 8476 +++++++++++++---- .../MetastoreGrpc.cs | 398 +- .../MetastoreResourceNames.g.cs | 357 + .../synth.metadata | 2 +- 7 files changed, 9851 insertions(+), 2086 deletions(-) diff --git a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha.Snippets/DataprocMetastoreClientSnippets.g.cs b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha.Snippets/DataprocMetastoreClientSnippets.g.cs index e52f837d6999..2e8a5a17e087 100644 --- a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha.Snippets/DataprocMetastoreClientSnippets.g.cs +++ b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha.Snippets/DataprocMetastoreClientSnippets.g.cs @@ -1599,5 +1599,1018 @@ public async Task UpdateMetadataImportAsync() } // End snippet } + + /// Snippet for ExportMetadata + public void ExportMetadataRequestObject() + { + // Snippet: ExportMetadata(ExportMetadataRequest, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + ExportMetadataRequest request = new ExportMetadataRequest + { + ServiceAsServiceName = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"), + DestinationGcsFolder = "", + RequestId = "", + DatabaseDumpType = DatabaseDumpSpec.Types.Type.Unspecified, + }; + // Make the request + Operation response = dataprocMetastoreClient.ExportMetadata(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + MetadataExport result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceExportMetadata(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + MetadataExport retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for ExportMetadataAsync + public async Task ExportMetadataRequestObjectAsync() + { + // Snippet: ExportMetadataAsync(ExportMetadataRequest, CallSettings) + // Additional: ExportMetadataAsync(ExportMetadataRequest, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + ExportMetadataRequest request = new ExportMetadataRequest + { + ServiceAsServiceName = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"), + DestinationGcsFolder = "", + RequestId = "", + DatabaseDumpType = DatabaseDumpSpec.Types.Type.Unspecified, + }; + // Make the request + Operation response = await dataprocMetastoreClient.ExportMetadataAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + MetadataExport result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceExportMetadataAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + MetadataExport retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for RestoreService + public void RestoreServiceRequestObject() + { + // Snippet: RestoreService(RestoreServiceRequest, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + RestoreServiceRequest request = new RestoreServiceRequest + { + ServiceAsServiceName = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"), + BackupAsBackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + RestoreType = Restore.Types.RestoreType.Unspecified, + RequestId = "", + }; + // Make the request + Operation response = dataprocMetastoreClient.RestoreService(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Restore result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceRestoreService(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Restore retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for RestoreServiceAsync + public async Task RestoreServiceRequestObjectAsync() + { + // Snippet: RestoreServiceAsync(RestoreServiceRequest, CallSettings) + // Additional: RestoreServiceAsync(RestoreServiceRequest, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + RestoreServiceRequest request = new RestoreServiceRequest + { + ServiceAsServiceName = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"), + BackupAsBackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + RestoreType = Restore.Types.RestoreType.Unspecified, + RequestId = "", + }; + // Make the request + Operation response = await dataprocMetastoreClient.RestoreServiceAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Restore result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceRestoreServiceAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Restore retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for RestoreService + public void RestoreService() + { + // Snippet: RestoreService(string, string, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + string service = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]"; + string backup = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]/backups/[BACKUP]"; + // Make the request + Operation response = dataprocMetastoreClient.RestoreService(service, backup); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Restore result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceRestoreService(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Restore retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for RestoreServiceAsync + public async Task RestoreServiceAsync() + { + // Snippet: RestoreServiceAsync(string, string, CallSettings) + // Additional: RestoreServiceAsync(string, string, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + string service = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]"; + string backup = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]/backups/[BACKUP]"; + // Make the request + Operation response = await dataprocMetastoreClient.RestoreServiceAsync(service, backup); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Restore result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceRestoreServiceAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Restore retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for RestoreService + public void RestoreServiceResourceNames() + { + // Snippet: RestoreService(ServiceName, BackupName, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + ServiceName service = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"); + BackupName backup = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"); + // Make the request + Operation response = dataprocMetastoreClient.RestoreService(service, backup); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Restore result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceRestoreService(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Restore retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for RestoreServiceAsync + public async Task RestoreServiceResourceNamesAsync() + { + // Snippet: RestoreServiceAsync(ServiceName, BackupName, CallSettings) + // Additional: RestoreServiceAsync(ServiceName, BackupName, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + ServiceName service = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"); + BackupName backup = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"); + // Make the request + Operation response = await dataprocMetastoreClient.RestoreServiceAsync(service, backup); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Restore result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceRestoreServiceAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Restore retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for ListBackups + public void ListBackupsRequestObject() + { + // Snippet: ListBackups(ListBackupsRequest, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + ListBackupsRequest request = new ListBackupsRequest + { + ParentAsServiceName = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"), + Filter = "", + OrderBy = "", + }; + // Make the request + PagedEnumerable response = dataprocMetastoreClient.ListBackups(request); + + // Iterate over all response items, lazily performing RPCs as required + foreach (Backup item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (ListBackupsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Backup item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Backup item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for ListBackups + public async Task ListBackupsRequestObjectAsync() + { + // Snippet: ListBackupsAsync(ListBackupsRequest, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + ListBackupsRequest request = new ListBackupsRequest + { + ParentAsServiceName = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"), + Filter = "", + OrderBy = "", + }; + // Make the request + PagedAsyncEnumerable response = dataprocMetastoreClient.ListBackupsAsync(request); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((Backup item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((ListBackupsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Backup item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Backup item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for ListBackups + public void ListBackups() + { + // Snippet: ListBackups(string, string, int?, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]"; + // Make the request + PagedEnumerable response = dataprocMetastoreClient.ListBackups(parent); + + // Iterate over all response items, lazily performing RPCs as required + foreach (Backup item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (ListBackupsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Backup item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Backup item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for ListBackups + public async Task ListBackupsAsync() + { + // Snippet: ListBackupsAsync(string, string, int?, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]"; + // Make the request + PagedAsyncEnumerable response = dataprocMetastoreClient.ListBackupsAsync(parent); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((Backup item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((ListBackupsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Backup item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Backup item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for ListBackups + public void ListBackupsResourceNames() + { + // Snippet: ListBackups(ServiceName, string, int?, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + ServiceName parent = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"); + // Make the request + PagedEnumerable response = dataprocMetastoreClient.ListBackups(parent); + + // Iterate over all response items, lazily performing RPCs as required + foreach (Backup item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (ListBackupsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Backup item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Backup item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for ListBackups + public async Task ListBackupsResourceNamesAsync() + { + // Snippet: ListBackupsAsync(ServiceName, string, int?, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + ServiceName parent = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"); + // Make the request + PagedAsyncEnumerable response = dataprocMetastoreClient.ListBackupsAsync(parent); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((Backup item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((ListBackupsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Backup item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Backup item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for GetBackup + public void GetBackupRequestObject() + { + // Snippet: GetBackup(GetBackupRequest, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + GetBackupRequest request = new GetBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + }; + // Make the request + Backup response = dataprocMetastoreClient.GetBackup(request); + // End snippet + } + + /// Snippet for GetBackupAsync + public async Task GetBackupRequestObjectAsync() + { + // Snippet: GetBackupAsync(GetBackupRequest, CallSettings) + // Additional: GetBackupAsync(GetBackupRequest, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + GetBackupRequest request = new GetBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + }; + // Make the request + Backup response = await dataprocMetastoreClient.GetBackupAsync(request); + // End snippet + } + + /// Snippet for GetBackup + public void GetBackup() + { + // Snippet: GetBackup(string, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]/backups/[BACKUP]"; + // Make the request + Backup response = dataprocMetastoreClient.GetBackup(name); + // End snippet + } + + /// Snippet for GetBackupAsync + public async Task GetBackupAsync() + { + // Snippet: GetBackupAsync(string, CallSettings) + // Additional: GetBackupAsync(string, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]/backups/[BACKUP]"; + // Make the request + Backup response = await dataprocMetastoreClient.GetBackupAsync(name); + // End snippet + } + + /// Snippet for GetBackup + public void GetBackupResourceNames() + { + // Snippet: GetBackup(BackupName, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + BackupName name = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"); + // Make the request + Backup response = dataprocMetastoreClient.GetBackup(name); + // End snippet + } + + /// Snippet for GetBackupAsync + public async Task GetBackupResourceNamesAsync() + { + // Snippet: GetBackupAsync(BackupName, CallSettings) + // Additional: GetBackupAsync(BackupName, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + BackupName name = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"); + // Make the request + Backup response = await dataprocMetastoreClient.GetBackupAsync(name); + // End snippet + } + + /// Snippet for CreateBackup + public void CreateBackupRequestObject() + { + // Snippet: CreateBackup(CreateBackupRequest, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + CreateBackupRequest request = new CreateBackupRequest + { + ParentAsServiceName = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"), + BackupId = "", + Backup = new Backup(), + RequestId = "", + }; + // Make the request + Operation response = dataprocMetastoreClient.CreateBackup(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Backup result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceCreateBackup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Backup retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for CreateBackupAsync + public async Task CreateBackupRequestObjectAsync() + { + // Snippet: CreateBackupAsync(CreateBackupRequest, CallSettings) + // Additional: CreateBackupAsync(CreateBackupRequest, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + CreateBackupRequest request = new CreateBackupRequest + { + ParentAsServiceName = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"), + BackupId = "", + Backup = new Backup(), + RequestId = "", + }; + // Make the request + Operation response = await dataprocMetastoreClient.CreateBackupAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Backup result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceCreateBackupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Backup retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for CreateBackup + public void CreateBackup() + { + // Snippet: CreateBackup(string, Backup, string, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]"; + Backup backup = new Backup(); + string backupId = ""; + // Make the request + Operation response = dataprocMetastoreClient.CreateBackup(parent, backup, backupId); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Backup result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceCreateBackup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Backup retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for CreateBackupAsync + public async Task CreateBackupAsync() + { + // Snippet: CreateBackupAsync(string, Backup, string, CallSettings) + // Additional: CreateBackupAsync(string, Backup, string, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]"; + Backup backup = new Backup(); + string backupId = ""; + // Make the request + Operation response = await dataprocMetastoreClient.CreateBackupAsync(parent, backup, backupId); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Backup result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceCreateBackupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Backup retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for CreateBackup + public void CreateBackupResourceNames() + { + // Snippet: CreateBackup(ServiceName, Backup, string, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + ServiceName parent = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"); + Backup backup = new Backup(); + string backupId = ""; + // Make the request + Operation response = dataprocMetastoreClient.CreateBackup(parent, backup, backupId); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Backup result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceCreateBackup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Backup retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for CreateBackupAsync + public async Task CreateBackupResourceNamesAsync() + { + // Snippet: CreateBackupAsync(ServiceName, Backup, string, CallSettings) + // Additional: CreateBackupAsync(ServiceName, Backup, string, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + ServiceName parent = ServiceName.FromProjectLocationService("[PROJECT]", "[LOCATION]", "[SERVICE]"); + Backup backup = new Backup(); + string backupId = ""; + // Make the request + Operation response = await dataprocMetastoreClient.CreateBackupAsync(parent, backup, backupId); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Backup result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceCreateBackupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Backup retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for DeleteBackup + public void DeleteBackupRequestObject() + { + // Snippet: DeleteBackup(DeleteBackupRequest, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + DeleteBackupRequest request = new DeleteBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + RequestId = "", + }; + // Make the request + Operation response = dataprocMetastoreClient.DeleteBackup(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Empty result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceDeleteBackup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Empty retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for DeleteBackupAsync + public async Task DeleteBackupRequestObjectAsync() + { + // Snippet: DeleteBackupAsync(DeleteBackupRequest, CallSettings) + // Additional: DeleteBackupAsync(DeleteBackupRequest, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + DeleteBackupRequest request = new DeleteBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + RequestId = "", + }; + // Make the request + Operation response = await dataprocMetastoreClient.DeleteBackupAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Empty result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceDeleteBackupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Empty retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for DeleteBackup + public void DeleteBackup() + { + // Snippet: DeleteBackup(string, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]/backups/[BACKUP]"; + // Make the request + Operation response = dataprocMetastoreClient.DeleteBackup(name); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Empty result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceDeleteBackup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Empty retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for DeleteBackupAsync + public async Task DeleteBackupAsync() + { + // Snippet: DeleteBackupAsync(string, CallSettings) + // Additional: DeleteBackupAsync(string, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/locations/[LOCATION]/services/[SERVICE]/backups/[BACKUP]"; + // Make the request + Operation response = await dataprocMetastoreClient.DeleteBackupAsync(name); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Empty result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceDeleteBackupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Empty retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for DeleteBackup + public void DeleteBackupResourceNames() + { + // Snippet: DeleteBackup(BackupName, CallSettings) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = DataprocMetastoreClient.Create(); + // Initialize request argument(s) + BackupName name = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"); + // Make the request + Operation response = dataprocMetastoreClient.DeleteBackup(name); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Empty result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = dataprocMetastoreClient.PollOnceDeleteBackup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Empty retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for DeleteBackupAsync + public async Task DeleteBackupResourceNamesAsync() + { + // Snippet: DeleteBackupAsync(BackupName, CallSettings) + // Additional: DeleteBackupAsync(BackupName, CancellationToken) + // Create client + DataprocMetastoreClient dataprocMetastoreClient = await DataprocMetastoreClient.CreateAsync(); + // Initialize request argument(s) + BackupName name = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"); + // Make the request + Operation response = await dataprocMetastoreClient.DeleteBackupAsync(name); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Empty result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await dataprocMetastoreClient.PollOnceDeleteBackupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Empty retrievedResult = retrievedResponse.Result; + } + // End snippet + } } } diff --git a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha.Tests/DataprocMetastoreClientTest.g.cs b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha.Tests/DataprocMetastoreClientTest.g.cs index 23dd1af970be..d0a1bdd410af 100644 --- a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha.Tests/DataprocMetastoreClientTest.g.cs +++ b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha.Tests/DataprocMetastoreClientTest.g.cs @@ -56,7 +56,11 @@ public void GetServiceRequestObject() State = Service.Types.State.Deleting, StateMessage = "state_message46cf28c0", ArtifactGcsUri = "artifact_gcs_uri4d2b3985", - Tier = Service.Types.Tier.Enterprise, + Tier = Service.Types.Tier.Developer, + MetadataIntegration = new MetadataIntegration(), + MaintenanceWindow = new MaintenanceWindow(), + Uid = "uida2d37198", + MetadataManagementActivity = new MetadataManagementActivity(), }; mockGrpcClient.Setup(x => x.GetService(request, moq::It.IsAny())).Returns(expectedResponse); DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); @@ -93,7 +97,11 @@ public void GetServiceRequestObject() State = Service.Types.State.Deleting, StateMessage = "state_message46cf28c0", ArtifactGcsUri = "artifact_gcs_uri4d2b3985", - Tier = Service.Types.Tier.Enterprise, + Tier = Service.Types.Tier.Developer, + MetadataIntegration = new MetadataIntegration(), + MaintenanceWindow = new MaintenanceWindow(), + Uid = "uida2d37198", + MetadataManagementActivity = new MetadataManagementActivity(), }; mockGrpcClient.Setup(x => x.GetServiceAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); @@ -132,7 +140,11 @@ public void GetService() State = Service.Types.State.Deleting, StateMessage = "state_message46cf28c0", ArtifactGcsUri = "artifact_gcs_uri4d2b3985", - Tier = Service.Types.Tier.Enterprise, + Tier = Service.Types.Tier.Developer, + MetadataIntegration = new MetadataIntegration(), + MaintenanceWindow = new MaintenanceWindow(), + Uid = "uida2d37198", + MetadataManagementActivity = new MetadataManagementActivity(), }; mockGrpcClient.Setup(x => x.GetService(request, moq::It.IsAny())).Returns(expectedResponse); DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); @@ -169,7 +181,11 @@ public void GetService() State = Service.Types.State.Deleting, StateMessage = "state_message46cf28c0", ArtifactGcsUri = "artifact_gcs_uri4d2b3985", - Tier = Service.Types.Tier.Enterprise, + Tier = Service.Types.Tier.Developer, + MetadataIntegration = new MetadataIntegration(), + MaintenanceWindow = new MaintenanceWindow(), + Uid = "uida2d37198", + MetadataManagementActivity = new MetadataManagementActivity(), }; mockGrpcClient.Setup(x => x.GetServiceAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); @@ -208,7 +224,11 @@ public void GetServiceResourceNames() State = Service.Types.State.Deleting, StateMessage = "state_message46cf28c0", ArtifactGcsUri = "artifact_gcs_uri4d2b3985", - Tier = Service.Types.Tier.Enterprise, + Tier = Service.Types.Tier.Developer, + MetadataIntegration = new MetadataIntegration(), + MaintenanceWindow = new MaintenanceWindow(), + Uid = "uida2d37198", + MetadataManagementActivity = new MetadataManagementActivity(), }; mockGrpcClient.Setup(x => x.GetService(request, moq::It.IsAny())).Returns(expectedResponse); DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); @@ -245,7 +265,11 @@ public void GetServiceResourceNames() State = Service.Types.State.Deleting, StateMessage = "state_message46cf28c0", ArtifactGcsUri = "artifact_gcs_uri4d2b3985", - Tier = Service.Types.Tier.Enterprise, + Tier = Service.Types.Tier.Developer, + MetadataIntegration = new MetadataIntegration(), + MaintenanceWindow = new MaintenanceWindow(), + Uid = "uida2d37198", + MetadataManagementActivity = new MetadataManagementActivity(), }; mockGrpcClient.Setup(x => x.GetServiceAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); @@ -411,5 +435,161 @@ public void GetMetadataImportResourceNames() xunit::Assert.Same(expectedResponse, responseCancellationToken); mockGrpcClient.VerifyAll(); } + + [xunit::FactAttribute] + public void GetBackupRequestObject() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + GetBackupRequest request = new GetBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + CreateTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + State = Backup.Types.State.Active, + ServiceRevision = new Service(), + Description = "description2cf9da67", + }; + mockGrpcClient.Setup(x => x.GetBackup(request, moq::It.IsAny())).Returns(expectedResponse); + DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); + Backup response = client.GetBackup(request); + xunit::Assert.Same(expectedResponse, response); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public async stt::Task GetBackupRequestObjectAsync() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + GetBackupRequest request = new GetBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + CreateTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + State = Backup.Types.State.Active, + ServiceRevision = new Service(), + Description = "description2cf9da67", + }; + mockGrpcClient.Setup(x => x.GetBackupAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); + DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); + Backup responseCallSettings = await client.GetBackupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); + xunit::Assert.Same(expectedResponse, responseCallSettings); + Backup responseCancellationToken = await client.GetBackupAsync(request, st::CancellationToken.None); + xunit::Assert.Same(expectedResponse, responseCancellationToken); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public void GetBackup() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + GetBackupRequest request = new GetBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + CreateTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + State = Backup.Types.State.Active, + ServiceRevision = new Service(), + Description = "description2cf9da67", + }; + mockGrpcClient.Setup(x => x.GetBackup(request, moq::It.IsAny())).Returns(expectedResponse); + DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); + Backup response = client.GetBackup(request.Name); + xunit::Assert.Same(expectedResponse, response); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public async stt::Task GetBackupAsync() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + GetBackupRequest request = new GetBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + CreateTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + State = Backup.Types.State.Active, + ServiceRevision = new Service(), + Description = "description2cf9da67", + }; + mockGrpcClient.Setup(x => x.GetBackupAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); + DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); + Backup responseCallSettings = await client.GetBackupAsync(request.Name, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); + xunit::Assert.Same(expectedResponse, responseCallSettings); + Backup responseCancellationToken = await client.GetBackupAsync(request.Name, st::CancellationToken.None); + xunit::Assert.Same(expectedResponse, responseCancellationToken); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public void GetBackupResourceNames() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + GetBackupRequest request = new GetBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + CreateTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + State = Backup.Types.State.Active, + ServiceRevision = new Service(), + Description = "description2cf9da67", + }; + mockGrpcClient.Setup(x => x.GetBackup(request, moq::It.IsAny())).Returns(expectedResponse); + DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); + Backup response = client.GetBackup(request.BackupName); + xunit::Assert.Same(expectedResponse, response); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public async stt::Task GetBackupResourceNamesAsync() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + GetBackupRequest request = new GetBackupRequest + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectLocationServiceBackup("[PROJECT]", "[LOCATION]", "[SERVICE]", "[BACKUP]"), + CreateTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + State = Backup.Types.State.Active, + ServiceRevision = new Service(), + Description = "description2cf9da67", + }; + mockGrpcClient.Setup(x => x.GetBackupAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); + DataprocMetastoreClient client = new DataprocMetastoreClientImpl(mockGrpcClient.Object, null); + Backup responseCallSettings = await client.GetBackupAsync(request.BackupName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); + xunit::Assert.Same(expectedResponse, responseCallSettings); + Backup responseCancellationToken = await client.GetBackupAsync(request.BackupName, st::CancellationToken.None); + xunit::Assert.Same(expectedResponse, responseCancellationToken); + mockGrpcClient.VerifyAll(); + } } } diff --git a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/DataprocMetastoreClient.g.cs b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/DataprocMetastoreClient.g.cs index 306e319617c6..2408a3194101 100644 --- a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/DataprocMetastoreClient.g.cs +++ b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/DataprocMetastoreClient.g.cs @@ -61,6 +61,16 @@ private DataprocMetastoreSettings(DataprocMetastoreSettings existing) : base(exi CreateMetadataImportOperationsSettings = existing.CreateMetadataImportOperationsSettings.Clone(); UpdateMetadataImportSettings = existing.UpdateMetadataImportSettings; UpdateMetadataImportOperationsSettings = existing.UpdateMetadataImportOperationsSettings.Clone(); + ExportMetadataSettings = existing.ExportMetadataSettings; + ExportMetadataOperationsSettings = existing.ExportMetadataOperationsSettings.Clone(); + RestoreServiceSettings = existing.RestoreServiceSettings; + RestoreServiceOperationsSettings = existing.RestoreServiceOperationsSettings.Clone(); + ListBackupsSettings = existing.ListBackupsSettings; + GetBackupSettings = existing.GetBackupSettings; + CreateBackupSettings = existing.CreateBackupSettings; + CreateBackupOperationsSettings = existing.CreateBackupOperationsSettings.Clone(); + DeleteBackupSettings = existing.DeleteBackupSettings; + DeleteBackupOperationsSettings = existing.DeleteBackupOperationsSettings.Clone(); OnCopy(existing); } @@ -279,6 +289,156 @@ private DataprocMetastoreSettings(DataprocMetastoreSettings existing) : base(exi DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)), }; + /// + /// for synchronous and asynchronous calls to + /// DataprocMetastoreClient.ExportMetadata and DataprocMetastoreClient.ExportMetadataAsync. + /// + /// + /// + /// This call will not be retried. + /// Timeout: 60 seconds. + /// + /// + public gaxgrpc::CallSettings ExportMetadataSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))); + + /// + /// Long Running Operation settings for calls to DataprocMetastoreClient.ExportMetadata and + /// DataprocMetastoreClient.ExportMetadataAsync. + /// + /// + /// Uses default of: + /// + /// Initial delay: 20 seconds. + /// Delay multiplier: 1.5 + /// Maximum delay: 45 seconds. + /// Total timeout: 24 hours. + /// + /// + public lro::OperationsSettings ExportMetadataOperationsSettings { get; set; } = new lro::OperationsSettings + { + DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)), + }; + + /// + /// for synchronous and asynchronous calls to + /// DataprocMetastoreClient.RestoreService and DataprocMetastoreClient.RestoreServiceAsync. + /// + /// + /// + /// This call will not be retried. + /// Timeout: 60 seconds. + /// + /// + public gaxgrpc::CallSettings RestoreServiceSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))); + + /// + /// Long Running Operation settings for calls to DataprocMetastoreClient.RestoreService and + /// DataprocMetastoreClient.RestoreServiceAsync. + /// + /// + /// Uses default of: + /// + /// Initial delay: 20 seconds. + /// Delay multiplier: 1.5 + /// Maximum delay: 45 seconds. + /// Total timeout: 24 hours. + /// + /// + public lro::OperationsSettings RestoreServiceOperationsSettings { get; set; } = new lro::OperationsSettings + { + DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)), + }; + + /// + /// for synchronous and asynchronous calls to + /// DataprocMetastoreClient.ListBackups and DataprocMetastoreClient.ListBackupsAsync. + /// + /// + /// + /// Initial retry delay: 1000 milliseconds. + /// Retry delay multiplier: 1.3 + /// Retry maximum delay: 10000 milliseconds. + /// Maximum attempts: 5 + /// Timeout: 60 seconds. + /// + /// + public gaxgrpc::CallSettings ListBackupsSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + + /// + /// for synchronous and asynchronous calls to + /// DataprocMetastoreClient.GetBackup and DataprocMetastoreClient.GetBackupAsync. + /// + /// + /// + /// Initial retry delay: 1000 milliseconds. + /// Retry delay multiplier: 1.3 + /// Retry maximum delay: 10000 milliseconds. + /// Maximum attempts: 5 + /// Timeout: 60 seconds. + /// + /// + public gaxgrpc::CallSettings GetBackupSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + + /// + /// for synchronous and asynchronous calls to + /// DataprocMetastoreClient.CreateBackup and DataprocMetastoreClient.CreateBackupAsync. + /// + /// + /// + /// This call will not be retried. + /// Timeout: 60 seconds. + /// + /// + public gaxgrpc::CallSettings CreateBackupSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))); + + /// + /// Long Running Operation settings for calls to DataprocMetastoreClient.CreateBackup and + /// DataprocMetastoreClient.CreateBackupAsync. + /// + /// + /// Uses default of: + /// + /// Initial delay: 20 seconds. + /// Delay multiplier: 1.5 + /// Maximum delay: 45 seconds. + /// Total timeout: 24 hours. + /// + /// + public lro::OperationsSettings CreateBackupOperationsSettings { get; set; } = new lro::OperationsSettings + { + DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)), + }; + + /// + /// for synchronous and asynchronous calls to + /// DataprocMetastoreClient.DeleteBackup and DataprocMetastoreClient.DeleteBackupAsync. + /// + /// + /// + /// This call will not be retried. + /// Timeout: 60 seconds. + /// + /// + public gaxgrpc::CallSettings DeleteBackupSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))); + + /// + /// Long Running Operation settings for calls to DataprocMetastoreClient.DeleteBackup and + /// DataprocMetastoreClient.DeleteBackupAsync. + /// + /// + /// Uses default of: + /// + /// Initial delay: 20 seconds. + /// Delay multiplier: 1.5 + /// Maximum delay: 45 seconds. + /// Total timeout: 24 hours. + /// + /// + public lro::OperationsSettings DeleteBackupOperationsSettings { get; set; } = new lro::OperationsSettings + { + DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)), + }; + /// Creates a deep clone of this object, with all the same property values. /// A deep clone of this object. public DataprocMetastoreSettings Clone() => new DataprocMetastoreSettings(this); @@ -360,7 +520,7 @@ private DataprocMetastoreClient BuildImpl() /// * Each location has a collection of services, named: `/services/*` /// * Dataproc Metastore services are resources with names of the form: /// - /// `/projects/{project_id}/locations/{location_id}/services/{service_id}`. + /// `/projects/{project_number}/locations/{location_id}/services/{service_id}`. /// public abstract partial class DataprocMetastoreClient { @@ -463,7 +623,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location of metastore services to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -490,7 +650,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location of metastore services to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -517,7 +677,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location of metastore services to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -544,7 +704,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location of metastore services to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -598,7 +758,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// If not null, applies overrides to this RPC call. /// The RPC response. @@ -615,7 +775,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// If not null, applies overrides to this RPC call. /// A Task containing the RPC response. @@ -632,7 +792,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// A to use for this RPC. /// A Task containing the RPC response. @@ -646,7 +806,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// If not null, applies overrides to this RPC call. /// The RPC response. @@ -663,7 +823,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// If not null, applies overrides to this RPC call. /// A Task containing the RPC response. @@ -680,7 +840,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// A to use for this RPC. /// A Task containing the RPC response. @@ -747,7 +907,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location in which to create a metastore /// service, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// Required. The Metastore service to create. The `name` field is @@ -758,7 +918,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The ID of the metastore service, which is used as the final /// component of the metastore service's name. /// - /// This value must be between 1 and 64 characters long, begin with a + /// This value must be between 2 and 63 characters long inclusive, begin with a /// letter, end with a letter or number, and consist of alpha-numeric /// ASCII characters or hyphens. /// @@ -779,7 +939,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location in which to create a metastore /// service, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// Required. The Metastore service to create. The `name` field is @@ -790,7 +950,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The ID of the metastore service, which is used as the final /// component of the metastore service's name. /// - /// This value must be between 1 and 64 characters long, begin with a + /// This value must be between 2 and 63 characters long inclusive, begin with a /// letter, end with a letter or number, and consist of alpha-numeric /// ASCII characters or hyphens. /// @@ -811,7 +971,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location in which to create a metastore /// service, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// Required. The Metastore service to create. The `name` field is @@ -822,7 +982,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The ID of the metastore service, which is used as the final /// component of the metastore service's name. /// - /// This value must be between 1 and 64 characters long, begin with a + /// This value must be between 2 and 63 characters long inclusive, begin with a /// letter, end with a letter or number, and consist of alpha-numeric /// ASCII characters or hyphens. /// @@ -838,7 +998,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location in which to create a metastore /// service, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// Required. The Metastore service to create. The `name` field is @@ -849,7 +1009,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The ID of the metastore service, which is used as the final /// component of the metastore service's name. /// - /// This value must be between 1 and 64 characters long, begin with a + /// This value must be between 2 and 63 characters long inclusive, begin with a /// letter, end with a letter or number, and consist of alpha-numeric /// ASCII characters or hyphens. /// @@ -870,7 +1030,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location in which to create a metastore /// service, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// Required. The Metastore service to create. The `name` field is @@ -881,7 +1041,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The ID of the metastore service, which is used as the final /// component of the metastore service's name. /// - /// This value must be between 1 and 64 characters long, begin with a + /// This value must be between 2 and 63 characters long inclusive, begin with a /// letter, end with a letter or number, and consist of alpha-numeric /// ASCII characters or hyphens. /// @@ -902,7 +1062,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the location in which to create a metastore /// service, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}`. /// /// /// Required. The Metastore service to create. The `name` field is @@ -913,7 +1073,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The ID of the metastore service, which is used as the final /// component of the metastore service's name. /// - /// This value must be between 1 and 64 characters long, begin with a + /// This value must be between 2 and 63 characters long inclusive, begin with a /// letter, end with a letter or number, and consist of alpha-numeric /// ASCII characters or hyphens. /// @@ -1106,7 +1266,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to delete, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// If not null, applies overrides to this RPC call. /// The RPC response. @@ -1123,7 +1283,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to delete, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// If not null, applies overrides to this RPC call. /// A Task containing the RPC response. @@ -1140,7 +1300,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to delete, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// A to use for this RPC. /// A Task containing the RPC response. @@ -1154,7 +1314,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to delete, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// If not null, applies overrides to this RPC call. /// The RPC response. @@ -1171,7 +1331,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to delete, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// If not null, applies overrides to this RPC call. /// A Task containing the RPC response. @@ -1188,7 +1348,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metastore service to delete, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// /// A to use for this RPC. /// A Task containing the RPC response. @@ -1220,7 +1380,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service whose metadata imports to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1247,7 +1407,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service whose metadata imports to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1274,7 +1434,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service whose metadata imports to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1301,7 +1461,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service whose metadata imports to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1355,7 +1515,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metadata import to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}`. /// /// If not null, applies overrides to this RPC call. /// The RPC response. @@ -1372,7 +1532,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metadata import to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}`. /// /// If not null, applies overrides to this RPC call. /// A Task containing the RPC response. @@ -1389,7 +1549,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metadata import to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}`. /// /// A to use for this RPC. /// A Task containing the RPC response. @@ -1403,7 +1563,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metadata import to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}`. /// /// If not null, applies overrides to this RPC call. /// The RPC response. @@ -1420,7 +1580,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metadata import to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}`. /// /// If not null, applies overrides to this RPC call. /// A Task containing the RPC response. @@ -1437,7 +1597,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the metadata import to retrieve, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}`. /// /// A to use for this RPC. /// A Task containing the RPC response. @@ -1505,7 +1665,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service in which to create a metastore /// import, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}" + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` /// /// /// Required. The metadata import to create. The `name` field is ignored. The ID of the @@ -1537,7 +1697,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service in which to create a metastore /// import, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}" + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` /// /// /// Required. The metadata import to create. The `name` field is ignored. The ID of the @@ -1569,7 +1729,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service in which to create a metastore /// import, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}" + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` /// /// /// Required. The metadata import to create. The `name` field is ignored. The ID of the @@ -1596,7 +1756,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service in which to create a metastore /// import, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}" + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` /// /// /// Required. The metadata import to create. The `name` field is ignored. The ID of the @@ -1628,7 +1788,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service in which to create a metastore /// import, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}" + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` /// /// /// Required. The metadata import to create. The `name` field is ignored. The ID of the @@ -1660,7 +1820,7 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// Required. The relative resource name of the service in which to create a metastore /// import, in the following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}" + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` /// /// /// Required. The metadata import to create. The `name` field is ignored. The ID of the @@ -1810,96 +1970,999 @@ internal static DataprocMetastoreClient Create(grpccore::CallInvoker callInvoker /// A Task containing the RPC response. public virtual stt::Task> UpdateMetadataImportAsync(MetadataImport metadataImport, wkt::FieldMask updateMask, st::CancellationToken cancellationToken) => UpdateMetadataImportAsync(metadataImport, updateMask, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); - } - - /// DataprocMetastore client wrapper implementation, for convenient use. - /// - /// Configures and manages metastore services. - /// Metastore services are fully managed, highly available, auto-scaled, - /// auto-healing, OSS-native deployments of technical metadata management - /// software. Each metastore service exposes a network endpoint through which - /// metadata queries are served. Metadata queries can originate from a variety - /// of sources, including Apache Hive, Apache Presto, and Apache Spark. - /// - /// The Dataproc Metastore API defines the following resource model: - /// - /// * The service works with a collection of Google Cloud projects, named: - /// `/projects/*` - /// * Each project has a collection of available locations, named: `/locations/*` - /// (a location must refer to a Google Cloud `region`) - /// * Each location has a collection of services, named: `/services/*` - /// * Dataproc Metastore services are resources with names of the form: - /// - /// `/projects/{project_id}/locations/{location_id}/services/{service_id}`. - /// - public sealed partial class DataprocMetastoreClientImpl : DataprocMetastoreClient - { - private readonly gaxgrpc::ApiCall _callListServices; - private readonly gaxgrpc::ApiCall _callGetService; + /// + /// Exports metadata from a service. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation ExportMetadata(ExportMetadataRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); - private readonly gaxgrpc::ApiCall _callCreateService; + /// + /// Exports metadata from a service. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> ExportMetadataAsync(ExportMetadataRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); - private readonly gaxgrpc::ApiCall _callUpdateService; + /// + /// Exports metadata from a service. + /// + /// The request object containing all of the parameters for the API call. + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> ExportMetadataAsync(ExportMetadataRequest request, st::CancellationToken cancellationToken) => + ExportMetadataAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); - private readonly gaxgrpc::ApiCall _callDeleteService; + /// The long-running operations client for ExportMetadata. + public virtual lro::OperationsClient ExportMetadataOperationsClient => throw new sys::NotImplementedException(); - private readonly gaxgrpc::ApiCall _callListMetadataImports; + /// + /// Poll an operation once, using an operationName from a previous invocation of ExportMetadata. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// The result of polling the operation. + public virtual lro::Operation PollOnceExportMetadata(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromName(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), ExportMetadataOperationsClient, callSettings); - private readonly gaxgrpc::ApiCall _callGetMetadataImport; + /// + /// Asynchronously poll an operation once, using an operationName from a previous invocation of + /// ExportMetadata. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// A task representing the result of polling the operation. + public virtual stt::Task> PollOnceExportMetadataAsync(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), ExportMetadataOperationsClient, callSettings); - private readonly gaxgrpc::ApiCall _callCreateMetadataImport; + /// + /// Restores a service from a backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation RestoreService(RestoreServiceRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); - private readonly gaxgrpc::ApiCall _callUpdateMetadataImport; + /// + /// Restores a service from a backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> RestoreServiceAsync(RestoreServiceRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); /// - /// Constructs a client wrapper for the DataprocMetastore service, with the specified gRPC client and settings. + /// Restores a service from a backup. /// - /// The underlying gRPC client. - /// The base used within this client. - public DataprocMetastoreClientImpl(DataprocMetastore.DataprocMetastoreClient grpcClient, DataprocMetastoreSettings settings) - { - GrpcClient = grpcClient; - DataprocMetastoreSettings effectiveSettings = settings ?? DataprocMetastoreSettings.GetDefault(); - gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings); - CreateServiceOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.CreateServiceOperationsSettings); - UpdateServiceOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.UpdateServiceOperationsSettings); - DeleteServiceOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.DeleteServiceOperationsSettings); - CreateMetadataImportOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.CreateMetadataImportOperationsSettings); - UpdateMetadataImportOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.UpdateMetadataImportOperationsSettings); - _callListServices = clientHelper.BuildApiCall(grpcClient.ListServicesAsync, grpcClient.ListServices, effectiveSettings.ListServicesSettings).WithGoogleRequestParam("parent", request => request.Parent); - Modify_ApiCall(ref _callListServices); - Modify_ListServicesApiCall(ref _callListServices); - _callGetService = clientHelper.BuildApiCall(grpcClient.GetServiceAsync, grpcClient.GetService, effectiveSettings.GetServiceSettings).WithGoogleRequestParam("name", request => request.Name); - Modify_ApiCall(ref _callGetService); - Modify_GetServiceApiCall(ref _callGetService); - _callCreateService = clientHelper.BuildApiCall(grpcClient.CreateServiceAsync, grpcClient.CreateService, effectiveSettings.CreateServiceSettings).WithGoogleRequestParam("parent", request => request.Parent); - Modify_ApiCall(ref _callCreateService); - Modify_CreateServiceApiCall(ref _callCreateService); - _callUpdateService = clientHelper.BuildApiCall(grpcClient.UpdateServiceAsync, grpcClient.UpdateService, effectiveSettings.UpdateServiceSettings).WithGoogleRequestParam("service.name", request => request.Service?.Name); - Modify_ApiCall(ref _callUpdateService); - Modify_UpdateServiceApiCall(ref _callUpdateService); - _callDeleteService = clientHelper.BuildApiCall(grpcClient.DeleteServiceAsync, grpcClient.DeleteService, effectiveSettings.DeleteServiceSettings).WithGoogleRequestParam("name", request => request.Name); - Modify_ApiCall(ref _callDeleteService); - Modify_DeleteServiceApiCall(ref _callDeleteService); - _callListMetadataImports = clientHelper.BuildApiCall(grpcClient.ListMetadataImportsAsync, grpcClient.ListMetadataImports, effectiveSettings.ListMetadataImportsSettings).WithGoogleRequestParam("parent", request => request.Parent); - Modify_ApiCall(ref _callListMetadataImports); - Modify_ListMetadataImportsApiCall(ref _callListMetadataImports); - _callGetMetadataImport = clientHelper.BuildApiCall(grpcClient.GetMetadataImportAsync, grpcClient.GetMetadataImport, effectiveSettings.GetMetadataImportSettings).WithGoogleRequestParam("name", request => request.Name); - Modify_ApiCall(ref _callGetMetadataImport); - Modify_GetMetadataImportApiCall(ref _callGetMetadataImport); - _callCreateMetadataImport = clientHelper.BuildApiCall(grpcClient.CreateMetadataImportAsync, grpcClient.CreateMetadataImport, effectiveSettings.CreateMetadataImportSettings).WithGoogleRequestParam("parent", request => request.Parent); - Modify_ApiCall(ref _callCreateMetadataImport); - Modify_CreateMetadataImportApiCall(ref _callCreateMetadataImport); - _callUpdateMetadataImport = clientHelper.BuildApiCall(grpcClient.UpdateMetadataImportAsync, grpcClient.UpdateMetadataImport, effectiveSettings.UpdateMetadataImportSettings).WithGoogleRequestParam("metadata_import.name", request => request.MetadataImport?.Name); - Modify_ApiCall(ref _callUpdateMetadataImport); - Modify_UpdateMetadataImportApiCall(ref _callUpdateMetadataImport); - OnConstruction(grpcClient, effectiveSettings, clientHelper); - } + /// The request object containing all of the parameters for the API call. + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> RestoreServiceAsync(RestoreServiceRequest request, st::CancellationToken cancellationToken) => + RestoreServiceAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); - partial void Modify_ApiCall(ref gaxgrpc::ApiCall call) where TRequest : class, proto::IMessage where TResponse : class, proto::IMessage; + /// The long-running operations client for RestoreService. + public virtual lro::OperationsClient RestoreServiceOperationsClient => throw new sys::NotImplementedException(); - partial void Modify_ListServicesApiCall(ref gaxgrpc::ApiCall call); + /// + /// Poll an operation once, using an operationName from a previous invocation of RestoreService. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// The result of polling the operation. + public virtual lro::Operation PollOnceRestoreService(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromName(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), RestoreServiceOperationsClient, callSettings); + + /// + /// Asynchronously poll an operation once, using an operationName from a previous invocation of + /// RestoreService. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// A task representing the result of polling the operation. + public virtual stt::Task> PollOnceRestoreServiceAsync(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), RestoreServiceOperationsClient, callSettings); + + /// + /// Restores a service from a backup. + /// + /// + /// Required. The relative resource name of the metastore service to run restore, in the + /// following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The relative resource name of the metastore service backup to restore + /// from, in the following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}` + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation RestoreService(string service, string backup, gaxgrpc::CallSettings callSettings = null) => + RestoreService(new RestoreServiceRequest + { + Service = gax::GaxPreconditions.CheckNotNullOrEmpty(service, nameof(service)), + Backup = gax::GaxPreconditions.CheckNotNullOrEmpty(backup, nameof(backup)), + }, callSettings); + + /// + /// Restores a service from a backup. + /// + /// + /// Required. The relative resource name of the metastore service to run restore, in the + /// following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The relative resource name of the metastore service backup to restore + /// from, in the following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}` + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> RestoreServiceAsync(string service, string backup, gaxgrpc::CallSettings callSettings = null) => + RestoreServiceAsync(new RestoreServiceRequest + { + Service = gax::GaxPreconditions.CheckNotNullOrEmpty(service, nameof(service)), + Backup = gax::GaxPreconditions.CheckNotNullOrEmpty(backup, nameof(backup)), + }, callSettings); + + /// + /// Restores a service from a backup. + /// + /// + /// Required. The relative resource name of the metastore service to run restore, in the + /// following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The relative resource name of the metastore service backup to restore + /// from, in the following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}` + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> RestoreServiceAsync(string service, string backup, st::CancellationToken cancellationToken) => + RestoreServiceAsync(service, backup, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Restores a service from a backup. + /// + /// + /// Required. The relative resource name of the metastore service to run restore, in the + /// following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The relative resource name of the metastore service backup to restore + /// from, in the following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}` + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation RestoreService(ServiceName service, BackupName backup, gaxgrpc::CallSettings callSettings = null) => + RestoreService(new RestoreServiceRequest + { + ServiceAsServiceName = gax::GaxPreconditions.CheckNotNull(service, nameof(service)), + BackupAsBackupName = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + }, callSettings); + + /// + /// Restores a service from a backup. + /// + /// + /// Required. The relative resource name of the metastore service to run restore, in the + /// following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The relative resource name of the metastore service backup to restore + /// from, in the following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}` + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> RestoreServiceAsync(ServiceName service, BackupName backup, gaxgrpc::CallSettings callSettings = null) => + RestoreServiceAsync(new RestoreServiceRequest + { + ServiceAsServiceName = gax::GaxPreconditions.CheckNotNull(service, nameof(service)), + BackupAsBackupName = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + }, callSettings); + + /// + /// Restores a service from a backup. + /// + /// + /// Required. The relative resource name of the metastore service to run restore, in the + /// following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The relative resource name of the metastore service backup to restore + /// from, in the following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}` + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> RestoreServiceAsync(ServiceName service, BackupName backup, st::CancellationToken cancellationToken) => + RestoreServiceAsync(service, backup, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Lists backups in a service. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public virtual gax::PagedEnumerable ListBackups(ListBackupsRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Lists backups in a service. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public virtual gax::PagedAsyncEnumerable ListBackupsAsync(ListBackupsRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Lists backups in a service. + /// + /// + /// Required. The relative resource name of the service whose backups to + /// list, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups`. + /// + /// + /// The token returned from the previous request. A value of null or an empty string retrieves the first + /// page. + /// + /// + /// The size of page to request. The response will not be larger than this, but may be smaller. A value of + /// null or 0 uses a server-defined page size. + /// + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public virtual gax::PagedEnumerable ListBackups(string parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) => + ListBackups(new ListBackupsRequest + { + Parent = gax::GaxPreconditions.CheckNotNullOrEmpty(parent, nameof(parent)), + PageToken = pageToken ?? "", + PageSize = pageSize ?? 0, + }, callSettings); + + /// + /// Lists backups in a service. + /// + /// + /// Required. The relative resource name of the service whose backups to + /// list, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups`. + /// + /// + /// The token returned from the previous request. A value of null or an empty string retrieves the first + /// page. + /// + /// + /// The size of page to request. The response will not be larger than this, but may be smaller. A value of + /// null or 0 uses a server-defined page size. + /// + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public virtual gax::PagedAsyncEnumerable ListBackupsAsync(string parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) => + ListBackupsAsync(new ListBackupsRequest + { + Parent = gax::GaxPreconditions.CheckNotNullOrEmpty(parent, nameof(parent)), + PageToken = pageToken ?? "", + PageSize = pageSize ?? 0, + }, callSettings); + + /// + /// Lists backups in a service. + /// + /// + /// Required. The relative resource name of the service whose backups to + /// list, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups`. + /// + /// + /// The token returned from the previous request. A value of null or an empty string retrieves the first + /// page. + /// + /// + /// The size of page to request. The response will not be larger than this, but may be smaller. A value of + /// null or 0 uses a server-defined page size. + /// + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public virtual gax::PagedEnumerable ListBackups(ServiceName parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) => + ListBackups(new ListBackupsRequest + { + ParentAsServiceName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + PageToken = pageToken ?? "", + PageSize = pageSize ?? 0, + }, callSettings); + + /// + /// Lists backups in a service. + /// + /// + /// Required. The relative resource name of the service whose backups to + /// list, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups`. + /// + /// + /// The token returned from the previous request. A value of null or an empty string retrieves the first + /// page. + /// + /// + /// The size of page to request. The response will not be larger than this, but may be smaller. A value of + /// null or 0 uses a server-defined page size. + /// + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public virtual gax::PagedAsyncEnumerable ListBackupsAsync(ServiceName parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) => + ListBackupsAsync(new ListBackupsRequest + { + ParentAsServiceName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + PageToken = pageToken ?? "", + PageSize = pageSize ?? 0, + }, callSettings); + + /// + /// Gets details of a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual Backup GetBackup(GetBackupRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Gets details of a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task GetBackupAsync(GetBackupRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Gets details of a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task GetBackupAsync(GetBackupRequest request, st::CancellationToken cancellationToken) => + GetBackupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Gets details of a single backup. + /// + /// + /// Required. The relative resource name of the backup to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual Backup GetBackup(string name, gaxgrpc::CallSettings callSettings = null) => + GetBackup(new GetBackupRequest + { + Name = gax::GaxPreconditions.CheckNotNullOrEmpty(name, nameof(name)), + }, callSettings); + + /// + /// Gets details of a single backup. + /// + /// + /// Required. The relative resource name of the backup to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task GetBackupAsync(string name, gaxgrpc::CallSettings callSettings = null) => + GetBackupAsync(new GetBackupRequest + { + Name = gax::GaxPreconditions.CheckNotNullOrEmpty(name, nameof(name)), + }, callSettings); + + /// + /// Gets details of a single backup. + /// + /// + /// Required. The relative resource name of the backup to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task GetBackupAsync(string name, st::CancellationToken cancellationToken) => + GetBackupAsync(name, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Gets details of a single backup. + /// + /// + /// Required. The relative resource name of the backup to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual Backup GetBackup(BackupName name, gaxgrpc::CallSettings callSettings = null) => + GetBackup(new GetBackupRequest + { + BackupName = gax::GaxPreconditions.CheckNotNull(name, nameof(name)), + }, callSettings); + + /// + /// Gets details of a single backup. + /// + /// + /// Required. The relative resource name of the backup to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task GetBackupAsync(BackupName name, gaxgrpc::CallSettings callSettings = null) => + GetBackupAsync(new GetBackupRequest + { + BackupName = gax::GaxPreconditions.CheckNotNull(name, nameof(name)), + }, callSettings); + + /// + /// Gets details of a single backup. + /// + /// + /// Required. The relative resource name of the backup to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task GetBackupAsync(BackupName name, st::CancellationToken cancellationToken) => + GetBackupAsync(name, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Creates a new Backup in a given project and location. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation CreateBackup(CreateBackupRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Creates a new Backup in a given project and location. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(CreateBackupRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Creates a new Backup in a given project and location. + /// + /// The request object containing all of the parameters for the API call. + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(CreateBackupRequest request, st::CancellationToken cancellationToken) => + CreateBackupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// The long-running operations client for CreateBackup. + public virtual lro::OperationsClient CreateBackupOperationsClient => throw new sys::NotImplementedException(); + + /// + /// Poll an operation once, using an operationName from a previous invocation of CreateBackup. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// The result of polling the operation. + public virtual lro::Operation PollOnceCreateBackup(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromName(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), CreateBackupOperationsClient, callSettings); + + /// + /// Asynchronously poll an operation once, using an operationName from a previous invocation of + /// CreateBackup. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// A task representing the result of polling the operation. + public virtual stt::Task> PollOnceCreateBackupAsync(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), CreateBackupOperationsClient, callSettings); + + /// + /// Creates a new Backup in a given project and location. + /// + /// + /// Required. The relative resource name of the service in which to create a backup + /// of the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The backup to create. The `name` field is ignored. The ID of the created + /// backup must be provided in the request's `backup_id` field. + /// + /// + /// Required. The ID of the backup, which is used as the final component of the + /// backup's name. + /// + /// This value must be between 1 and 64 characters long, begin with a letter, + /// end with a letter or number, and consist of alpha-numeric ASCII characters + /// or hyphens. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation CreateBackup(string parent, Backup backup, string backupId, gaxgrpc::CallSettings callSettings = null) => + CreateBackup(new CreateBackupRequest + { + Parent = gax::GaxPreconditions.CheckNotNullOrEmpty(parent, nameof(parent)), + BackupId = gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId)), + Backup = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + }, callSettings); + + /// + /// Creates a new Backup in a given project and location. + /// + /// + /// Required. The relative resource name of the service in which to create a backup + /// of the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The backup to create. The `name` field is ignored. The ID of the created + /// backup must be provided in the request's `backup_id` field. + /// + /// + /// Required. The ID of the backup, which is used as the final component of the + /// backup's name. + /// + /// This value must be between 1 and 64 characters long, begin with a letter, + /// end with a letter or number, and consist of alpha-numeric ASCII characters + /// or hyphens. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(string parent, Backup backup, string backupId, gaxgrpc::CallSettings callSettings = null) => + CreateBackupAsync(new CreateBackupRequest + { + Parent = gax::GaxPreconditions.CheckNotNullOrEmpty(parent, nameof(parent)), + BackupId = gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId)), + Backup = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + }, callSettings); + + /// + /// Creates a new Backup in a given project and location. + /// + /// + /// Required. The relative resource name of the service in which to create a backup + /// of the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The backup to create. The `name` field is ignored. The ID of the created + /// backup must be provided in the request's `backup_id` field. + /// + /// + /// Required. The ID of the backup, which is used as the final component of the + /// backup's name. + /// + /// This value must be between 1 and 64 characters long, begin with a letter, + /// end with a letter or number, and consist of alpha-numeric ASCII characters + /// or hyphens. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(string parent, Backup backup, string backupId, st::CancellationToken cancellationToken) => + CreateBackupAsync(parent, backup, backupId, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Creates a new Backup in a given project and location. + /// + /// + /// Required. The relative resource name of the service in which to create a backup + /// of the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The backup to create. The `name` field is ignored. The ID of the created + /// backup must be provided in the request's `backup_id` field. + /// + /// + /// Required. The ID of the backup, which is used as the final component of the + /// backup's name. + /// + /// This value must be between 1 and 64 characters long, begin with a letter, + /// end with a letter or number, and consist of alpha-numeric ASCII characters + /// or hyphens. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation CreateBackup(ServiceName parent, Backup backup, string backupId, gaxgrpc::CallSettings callSettings = null) => + CreateBackup(new CreateBackupRequest + { + ParentAsServiceName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + BackupId = gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId)), + Backup = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + }, callSettings); + + /// + /// Creates a new Backup in a given project and location. + /// + /// + /// Required. The relative resource name of the service in which to create a backup + /// of the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The backup to create. The `name` field is ignored. The ID of the created + /// backup must be provided in the request's `backup_id` field. + /// + /// + /// Required. The ID of the backup, which is used as the final component of the + /// backup's name. + /// + /// This value must be between 1 and 64 characters long, begin with a letter, + /// end with a letter or number, and consist of alpha-numeric ASCII characters + /// or hyphens. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(ServiceName parent, Backup backup, string backupId, gaxgrpc::CallSettings callSettings = null) => + CreateBackupAsync(new CreateBackupRequest + { + ParentAsServiceName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + BackupId = gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId)), + Backup = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + }, callSettings); + + /// + /// Creates a new Backup in a given project and location. + /// + /// + /// Required. The relative resource name of the service in which to create a backup + /// of the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` + /// + /// + /// Required. The backup to create. The `name` field is ignored. The ID of the created + /// backup must be provided in the request's `backup_id` field. + /// + /// + /// Required. The ID of the backup, which is used as the final component of the + /// backup's name. + /// + /// This value must be between 1 and 64 characters long, begin with a letter, + /// end with a letter or number, and consist of alpha-numeric ASCII characters + /// or hyphens. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(ServiceName parent, Backup backup, string backupId, st::CancellationToken cancellationToken) => + CreateBackupAsync(parent, backup, backupId, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Deletes a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation DeleteBackup(DeleteBackupRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Deletes a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> DeleteBackupAsync(DeleteBackupRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Deletes a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> DeleteBackupAsync(DeleteBackupRequest request, st::CancellationToken cancellationToken) => + DeleteBackupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// The long-running operations client for DeleteBackup. + public virtual lro::OperationsClient DeleteBackupOperationsClient => throw new sys::NotImplementedException(); + + /// + /// Poll an operation once, using an operationName from a previous invocation of DeleteBackup. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// The result of polling the operation. + public virtual lro::Operation PollOnceDeleteBackup(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromName(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), DeleteBackupOperationsClient, callSettings); + + /// + /// Asynchronously poll an operation once, using an operationName from a previous invocation of + /// DeleteBackup. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// A task representing the result of polling the operation. + public virtual stt::Task> PollOnceDeleteBackupAsync(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), DeleteBackupOperationsClient, callSettings); + + /// + /// Deletes a single backup. + /// + /// + /// Required. The relative resource name of the backup to delete, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation DeleteBackup(string name, gaxgrpc::CallSettings callSettings = null) => + DeleteBackup(new DeleteBackupRequest + { + Name = gax::GaxPreconditions.CheckNotNullOrEmpty(name, nameof(name)), + }, callSettings); + + /// + /// Deletes a single backup. + /// + /// + /// Required. The relative resource name of the backup to delete, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> DeleteBackupAsync(string name, gaxgrpc::CallSettings callSettings = null) => + DeleteBackupAsync(new DeleteBackupRequest + { + Name = gax::GaxPreconditions.CheckNotNullOrEmpty(name, nameof(name)), + }, callSettings); + + /// + /// Deletes a single backup. + /// + /// + /// Required. The relative resource name of the backup to delete, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> DeleteBackupAsync(string name, st::CancellationToken cancellationToken) => + DeleteBackupAsync(name, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Deletes a single backup. + /// + /// + /// Required. The relative resource name of the backup to delete, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation DeleteBackup(BackupName name, gaxgrpc::CallSettings callSettings = null) => + DeleteBackup(new DeleteBackupRequest + { + BackupName = gax::GaxPreconditions.CheckNotNull(name, nameof(name)), + }, callSettings); + + /// + /// Deletes a single backup. + /// + /// + /// Required. The relative resource name of the backup to delete, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> DeleteBackupAsync(BackupName name, gaxgrpc::CallSettings callSettings = null) => + DeleteBackupAsync(new DeleteBackupRequest + { + BackupName = gax::GaxPreconditions.CheckNotNull(name, nameof(name)), + }, callSettings); + + /// + /// Deletes a single backup. + /// + /// + /// Required. The relative resource name of the backup to delete, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> DeleteBackupAsync(BackupName name, st::CancellationToken cancellationToken) => + DeleteBackupAsync(name, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + } + + /// DataprocMetastore client wrapper implementation, for convenient use. + /// + /// Configures and manages metastore services. + /// Metastore services are fully managed, highly available, auto-scaled, + /// auto-healing, OSS-native deployments of technical metadata management + /// software. Each metastore service exposes a network endpoint through which + /// metadata queries are served. Metadata queries can originate from a variety + /// of sources, including Apache Hive, Apache Presto, and Apache Spark. + /// + /// The Dataproc Metastore API defines the following resource model: + /// + /// * The service works with a collection of Google Cloud projects, named: + /// `/projects/*` + /// * Each project has a collection of available locations, named: `/locations/*` + /// (a location must refer to a Google Cloud `region`) + /// * Each location has a collection of services, named: `/services/*` + /// * Dataproc Metastore services are resources with names of the form: + /// + /// `/projects/{project_number}/locations/{location_id}/services/{service_id}`. + /// + public sealed partial class DataprocMetastoreClientImpl : DataprocMetastoreClient + { + private readonly gaxgrpc::ApiCall _callListServices; + + private readonly gaxgrpc::ApiCall _callGetService; + + private readonly gaxgrpc::ApiCall _callCreateService; + + private readonly gaxgrpc::ApiCall _callUpdateService; + + private readonly gaxgrpc::ApiCall _callDeleteService; + + private readonly gaxgrpc::ApiCall _callListMetadataImports; + + private readonly gaxgrpc::ApiCall _callGetMetadataImport; + + private readonly gaxgrpc::ApiCall _callCreateMetadataImport; + + private readonly gaxgrpc::ApiCall _callUpdateMetadataImport; + + private readonly gaxgrpc::ApiCall _callExportMetadata; + + private readonly gaxgrpc::ApiCall _callRestoreService; + + private readonly gaxgrpc::ApiCall _callListBackups; + + private readonly gaxgrpc::ApiCall _callGetBackup; + + private readonly gaxgrpc::ApiCall _callCreateBackup; + + private readonly gaxgrpc::ApiCall _callDeleteBackup; + + /// + /// Constructs a client wrapper for the DataprocMetastore service, with the specified gRPC client and settings. + /// + /// The underlying gRPC client. + /// The base used within this client. + public DataprocMetastoreClientImpl(DataprocMetastore.DataprocMetastoreClient grpcClient, DataprocMetastoreSettings settings) + { + GrpcClient = grpcClient; + DataprocMetastoreSettings effectiveSettings = settings ?? DataprocMetastoreSettings.GetDefault(); + gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(effectiveSettings); + CreateServiceOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.CreateServiceOperationsSettings); + UpdateServiceOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.UpdateServiceOperationsSettings); + DeleteServiceOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.DeleteServiceOperationsSettings); + CreateMetadataImportOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.CreateMetadataImportOperationsSettings); + UpdateMetadataImportOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.UpdateMetadataImportOperationsSettings); + ExportMetadataOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.ExportMetadataOperationsSettings); + RestoreServiceOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.RestoreServiceOperationsSettings); + CreateBackupOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.CreateBackupOperationsSettings); + DeleteBackupOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.DeleteBackupOperationsSettings); + _callListServices = clientHelper.BuildApiCall(grpcClient.ListServicesAsync, grpcClient.ListServices, effectiveSettings.ListServicesSettings).WithGoogleRequestParam("parent", request => request.Parent); + Modify_ApiCall(ref _callListServices); + Modify_ListServicesApiCall(ref _callListServices); + _callGetService = clientHelper.BuildApiCall(grpcClient.GetServiceAsync, grpcClient.GetService, effectiveSettings.GetServiceSettings).WithGoogleRequestParam("name", request => request.Name); + Modify_ApiCall(ref _callGetService); + Modify_GetServiceApiCall(ref _callGetService); + _callCreateService = clientHelper.BuildApiCall(grpcClient.CreateServiceAsync, grpcClient.CreateService, effectiveSettings.CreateServiceSettings).WithGoogleRequestParam("parent", request => request.Parent); + Modify_ApiCall(ref _callCreateService); + Modify_CreateServiceApiCall(ref _callCreateService); + _callUpdateService = clientHelper.BuildApiCall(grpcClient.UpdateServiceAsync, grpcClient.UpdateService, effectiveSettings.UpdateServiceSettings).WithGoogleRequestParam("service.name", request => request.Service?.Name); + Modify_ApiCall(ref _callUpdateService); + Modify_UpdateServiceApiCall(ref _callUpdateService); + _callDeleteService = clientHelper.BuildApiCall(grpcClient.DeleteServiceAsync, grpcClient.DeleteService, effectiveSettings.DeleteServiceSettings).WithGoogleRequestParam("name", request => request.Name); + Modify_ApiCall(ref _callDeleteService); + Modify_DeleteServiceApiCall(ref _callDeleteService); + _callListMetadataImports = clientHelper.BuildApiCall(grpcClient.ListMetadataImportsAsync, grpcClient.ListMetadataImports, effectiveSettings.ListMetadataImportsSettings).WithGoogleRequestParam("parent", request => request.Parent); + Modify_ApiCall(ref _callListMetadataImports); + Modify_ListMetadataImportsApiCall(ref _callListMetadataImports); + _callGetMetadataImport = clientHelper.BuildApiCall(grpcClient.GetMetadataImportAsync, grpcClient.GetMetadataImport, effectiveSettings.GetMetadataImportSettings).WithGoogleRequestParam("name", request => request.Name); + Modify_ApiCall(ref _callGetMetadataImport); + Modify_GetMetadataImportApiCall(ref _callGetMetadataImport); + _callCreateMetadataImport = clientHelper.BuildApiCall(grpcClient.CreateMetadataImportAsync, grpcClient.CreateMetadataImport, effectiveSettings.CreateMetadataImportSettings).WithGoogleRequestParam("parent", request => request.Parent); + Modify_ApiCall(ref _callCreateMetadataImport); + Modify_CreateMetadataImportApiCall(ref _callCreateMetadataImport); + _callUpdateMetadataImport = clientHelper.BuildApiCall(grpcClient.UpdateMetadataImportAsync, grpcClient.UpdateMetadataImport, effectiveSettings.UpdateMetadataImportSettings).WithGoogleRequestParam("metadata_import.name", request => request.MetadataImport?.Name); + Modify_ApiCall(ref _callUpdateMetadataImport); + Modify_UpdateMetadataImportApiCall(ref _callUpdateMetadataImport); + _callExportMetadata = clientHelper.BuildApiCall(grpcClient.ExportMetadataAsync, grpcClient.ExportMetadata, effectiveSettings.ExportMetadataSettings).WithGoogleRequestParam("service", request => request.Service); + Modify_ApiCall(ref _callExportMetadata); + Modify_ExportMetadataApiCall(ref _callExportMetadata); + _callRestoreService = clientHelper.BuildApiCall(grpcClient.RestoreServiceAsync, grpcClient.RestoreService, effectiveSettings.RestoreServiceSettings).WithGoogleRequestParam("service", request => request.Service); + Modify_ApiCall(ref _callRestoreService); + Modify_RestoreServiceApiCall(ref _callRestoreService); + _callListBackups = clientHelper.BuildApiCall(grpcClient.ListBackupsAsync, grpcClient.ListBackups, effectiveSettings.ListBackupsSettings).WithGoogleRequestParam("parent", request => request.Parent); + Modify_ApiCall(ref _callListBackups); + Modify_ListBackupsApiCall(ref _callListBackups); + _callGetBackup = clientHelper.BuildApiCall(grpcClient.GetBackupAsync, grpcClient.GetBackup, effectiveSettings.GetBackupSettings).WithGoogleRequestParam("name", request => request.Name); + Modify_ApiCall(ref _callGetBackup); + Modify_GetBackupApiCall(ref _callGetBackup); + _callCreateBackup = clientHelper.BuildApiCall(grpcClient.CreateBackupAsync, grpcClient.CreateBackup, effectiveSettings.CreateBackupSettings).WithGoogleRequestParam("parent", request => request.Parent); + Modify_ApiCall(ref _callCreateBackup); + Modify_CreateBackupApiCall(ref _callCreateBackup); + _callDeleteBackup = clientHelper.BuildApiCall(grpcClient.DeleteBackupAsync, grpcClient.DeleteBackup, effectiveSettings.DeleteBackupSettings).WithGoogleRequestParam("name", request => request.Name); + Modify_ApiCall(ref _callDeleteBackup); + Modify_DeleteBackupApiCall(ref _callDeleteBackup); + OnConstruction(grpcClient, effectiveSettings, clientHelper); + } + + partial void Modify_ApiCall(ref gaxgrpc::ApiCall call) where TRequest : class, proto::IMessage where TResponse : class, proto::IMessage; + + partial void Modify_ListServicesApiCall(ref gaxgrpc::ApiCall call); partial void Modify_GetServiceApiCall(ref gaxgrpc::ApiCall call); @@ -1917,6 +2980,18 @@ public DataprocMetastoreClientImpl(DataprocMetastore.DataprocMetastoreClient grp partial void Modify_UpdateMetadataImportApiCall(ref gaxgrpc::ApiCall call); + partial void Modify_ExportMetadataApiCall(ref gaxgrpc::ApiCall call); + + partial void Modify_RestoreServiceApiCall(ref gaxgrpc::ApiCall call); + + partial void Modify_ListBackupsApiCall(ref gaxgrpc::ApiCall call); + + partial void Modify_GetBackupApiCall(ref gaxgrpc::ApiCall call); + + partial void Modify_CreateBackupApiCall(ref gaxgrpc::ApiCall call); + + partial void Modify_DeleteBackupApiCall(ref gaxgrpc::ApiCall call); + partial void OnConstruction(DataprocMetastore.DataprocMetastoreClient grpcClient, DataprocMetastoreSettings effectiveSettings, gaxgrpc::ClientHelper clientHelper); /// The underlying gRPC DataprocMetastore client @@ -1940,6 +3015,18 @@ public DataprocMetastoreClientImpl(DataprocMetastore.DataprocMetastoreClient grp partial void Modify_UpdateMetadataImportRequest(ref UpdateMetadataImportRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_ExportMetadataRequest(ref ExportMetadataRequest request, ref gaxgrpc::CallSettings settings); + + partial void Modify_RestoreServiceRequest(ref RestoreServiceRequest request, ref gaxgrpc::CallSettings settings); + + partial void Modify_ListBackupsRequest(ref ListBackupsRequest request, ref gaxgrpc::CallSettings settings); + + partial void Modify_GetBackupRequest(ref GetBackupRequest request, ref gaxgrpc::CallSettings settings); + + partial void Modify_CreateBackupRequest(ref CreateBackupRequest request, ref gaxgrpc::CallSettings settings); + + partial void Modify_DeleteBackupRequest(ref DeleteBackupRequest request, ref gaxgrpc::CallSettings settings); + /// /// Lists services in a project and location. /// @@ -2172,6 +3259,162 @@ public override MetadataImport GetMetadataImport(GetMetadataImportRequest reques Modify_UpdateMetadataImportRequest(ref request, ref callSettings); return new lro::Operation(await _callUpdateMetadataImport.Async(request, callSettings).ConfigureAwait(false), UpdateMetadataImportOperationsClient); } + + /// The long-running operations client for ExportMetadata. + public override lro::OperationsClient ExportMetadataOperationsClient { get; } + + /// + /// Exports metadata from a service. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public override lro::Operation ExportMetadata(ExportMetadataRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_ExportMetadataRequest(ref request, ref callSettings); + return new lro::Operation(_callExportMetadata.Sync(request, callSettings), ExportMetadataOperationsClient); + } + + /// + /// Exports metadata from a service. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public override async stt::Task> ExportMetadataAsync(ExportMetadataRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_ExportMetadataRequest(ref request, ref callSettings); + return new lro::Operation(await _callExportMetadata.Async(request, callSettings).ConfigureAwait(false), ExportMetadataOperationsClient); + } + + /// The long-running operations client for RestoreService. + public override lro::OperationsClient RestoreServiceOperationsClient { get; } + + /// + /// Restores a service from a backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public override lro::Operation RestoreService(RestoreServiceRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_RestoreServiceRequest(ref request, ref callSettings); + return new lro::Operation(_callRestoreService.Sync(request, callSettings), RestoreServiceOperationsClient); + } + + /// + /// Restores a service from a backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public override async stt::Task> RestoreServiceAsync(RestoreServiceRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_RestoreServiceRequest(ref request, ref callSettings); + return new lro::Operation(await _callRestoreService.Async(request, callSettings).ConfigureAwait(false), RestoreServiceOperationsClient); + } + + /// + /// Lists backups in a service. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public override gax::PagedEnumerable ListBackups(ListBackupsRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_ListBackupsRequest(ref request, ref callSettings); + return new gaxgrpc::GrpcPagedEnumerable(_callListBackups, request, callSettings); + } + + /// + /// Lists backups in a service. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public override gax::PagedAsyncEnumerable ListBackupsAsync(ListBackupsRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_ListBackupsRequest(ref request, ref callSettings); + return new gaxgrpc::GrpcPagedAsyncEnumerable(_callListBackups, request, callSettings); + } + + /// + /// Gets details of a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public override Backup GetBackup(GetBackupRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_GetBackupRequest(ref request, ref callSettings); + return _callGetBackup.Sync(request, callSettings); + } + + /// + /// Gets details of a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public override stt::Task GetBackupAsync(GetBackupRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_GetBackupRequest(ref request, ref callSettings); + return _callGetBackup.Async(request, callSettings); + } + + /// The long-running operations client for CreateBackup. + public override lro::OperationsClient CreateBackupOperationsClient { get; } + + /// + /// Creates a new Backup in a given project and location. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public override lro::Operation CreateBackup(CreateBackupRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_CreateBackupRequest(ref request, ref callSettings); + return new lro::Operation(_callCreateBackup.Sync(request, callSettings), CreateBackupOperationsClient); + } + + /// + /// Creates a new Backup in a given project and location. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public override async stt::Task> CreateBackupAsync(CreateBackupRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_CreateBackupRequest(ref request, ref callSettings); + return new lro::Operation(await _callCreateBackup.Async(request, callSettings).ConfigureAwait(false), CreateBackupOperationsClient); + } + + /// The long-running operations client for DeleteBackup. + public override lro::OperationsClient DeleteBackupOperationsClient { get; } + + /// + /// Deletes a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public override lro::Operation DeleteBackup(DeleteBackupRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_DeleteBackupRequest(ref request, ref callSettings); + return new lro::Operation(_callDeleteBackup.Sync(request, callSettings), DeleteBackupOperationsClient); + } + + /// + /// Deletes a single backup. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public override async stt::Task> DeleteBackupAsync(DeleteBackupRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_DeleteBackupRequest(ref request, ref callSettings); + return new lro::Operation(await _callDeleteBackup.Async(request, callSettings).ConfigureAwait(false), DeleteBackupOperationsClient); + } } public partial class ListServicesRequest : gaxgrpc::IPageRequest @@ -2182,6 +3425,10 @@ public partial class ListMetadataImportsRequest : gaxgrpc::IPageRequest { } + public partial class ListBackupsRequest : gaxgrpc::IPageRequest + { + } + public partial class ListServicesResponse : gaxgrpc::IPageResponse { /// Returns an enumerator that iterates through the resources in this response. @@ -2198,6 +3445,14 @@ public partial class ListMetadataImportsResponse : gaxgrpc::IPageResponse GetEnumerator(); } + public partial class ListBackupsResponse : gaxgrpc::IPageResponse + { + /// Returns an enumerator that iterates through the resources in this response. + public scg::IEnumerator GetEnumerator() => Backups.GetEnumerator(); + + sc::IEnumerator sc::IEnumerable.GetEnumerator() => GetEnumerator(); + } + public static partial class DataprocMetastore { public partial class DataprocMetastoreClient diff --git a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/Metastore.cs b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/Metastore.cs index 5fd8ac44ac8d..b51c7652cfa1 100644 --- a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/Metastore.cs +++ b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/Metastore.cs @@ -30,164 +30,277 @@ public static partial class MetastoreReflection { "Gh9nb29nbGUvYXBpL2ZpZWxkX2JlaGF2aW9yLnByb3RvGhlnb29nbGUvYXBp", "L3Jlc291cmNlLnByb3RvGiNnb29nbGUvbG9uZ3J1bm5pbmcvb3BlcmF0aW9u", "cy5wcm90bxogZ29vZ2xlL3Byb3RvYnVmL2ZpZWxkX21hc2sucHJvdG8aH2dv", - "b2dsZS9wcm90b2J1Zi90aW1lc3RhbXAucHJvdG8ikwcKB1NlcnZpY2USEQoE", - "bmFtZRgBIAEoCUID4EEFEjQKC2NyZWF0ZV90aW1lGAIgASgLMhouZ29vZ2xl", - "LnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEjQKC3VwZGF0ZV90aW1lGAMgASgL", - "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEkMKBmxhYmVscxgE", - "IAMoCzIzLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5TZXJ2aWNl", - "LkxhYmVsc0VudHJ5ElQKFWhpdmVfbWV0YXN0b3JlX2NvbmZpZxgFIAEoCzIz", + "b2dsZS9wcm90b2J1Zi90aW1lc3RhbXAucHJvdG8aHmdvb2dsZS9wcm90b2J1", + "Zi93cmFwcGVycy5wcm90bxobZ29vZ2xlL3R5cGUvZGF5b2Z3ZWVrLnByb3Rv", + "Ir0JCgdTZXJ2aWNlElQKFWhpdmVfbWV0YXN0b3JlX2NvbmZpZxgFIAEoCzIz", "Lmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5IaXZlTWV0YXN0b3Jl", - "Q29uZmlnSAASNwoHbmV0d29yaxgHIAEoCUIm4EEF+kEgCh5jb21wdXRlLmdv", - "b2dsZWFwaXMuY29tL05ldHdvcmsSGQoMZW5kcG9pbnRfdXJpGAggASgJQgPg", - "QQMSDAoEcG9ydBgJIAEoBRJBCgVzdGF0ZRgKIAEoDjItLmdvb2dsZS5jbG91", - "ZC5tZXRhc3RvcmUudjFhbHBoYS5TZXJ2aWNlLlN0YXRlQgPgQQMSGgoNc3Rh", - "dGVfbWVzc2FnZRgLIAEoCUID4EEDEh0KEGFydGlmYWN0X2djc191cmkYDCAB", - "KAlCA+BBAxI6CgR0aWVyGA0gASgOMiwuZ29vZ2xlLmNsb3VkLm1ldGFzdG9y", - "ZS52MWFscGhhLlNlcnZpY2UuVGllchotCgtMYWJlbHNFbnRyeRILCgNrZXkY", - "ASABKAkSDQoFdmFsdWUYAiABKAk6AjgBIn4KBVN0YXRlEhUKEVNUQVRFX1VO", - "U1BFQ0lGSUVEEAASDAoIQ1JFQVRJTkcQARIKCgZBQ1RJVkUQAhIOCgpTVVNQ", - "RU5ESU5HEAMSDQoJU1VTUEVOREVEEAQSDAoIVVBEQVRJTkcQBRIMCghERUxF", - "VElORxAGEgkKBUVSUk9SEAciLAoEVGllchIUChBUSUVSX1VOU1BFQ0lGSUVE", - "EAASDgoKRU5URVJQUklTRRADOmHqQV4KIG1ldGFzdG9yZS5nb29nbGVhcGlz", - "LmNvbS9TZXJ2aWNlEjpwcm9qZWN0cy97cHJvamVjdH0vbG9jYXRpb25zL3ts", - "b2NhdGlvbn0vc2VydmljZXMve3NlcnZpY2V9QhIKEG1ldGFzdG9yZV9jb25m", - "aWcikAIKE0hpdmVNZXRhc3RvcmVDb25maWcSFAoHdmVyc2lvbhgBIAEoCUID", - "4EEFEmIKEGNvbmZpZ19vdmVycmlkZXMYAiADKAsySC5nb29nbGUuY2xvdWQu", - "bWV0YXN0b3JlLnYxYWxwaGEuSGl2ZU1ldGFzdG9yZUNvbmZpZy5Db25maWdP", - "dmVycmlkZXNFbnRyeRJHCg9rZXJiZXJvc19jb25maWcYAyABKAsyLi5nb29n", - "bGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuS2VyYmVyb3NDb25maWcaNgoU", - "Q29uZmlnT3ZlcnJpZGVzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIg", - "ASgJOgI4ASJ4Cg5LZXJiZXJvc0NvbmZpZxI2CgZrZXl0YWIYASABKAsyJi5n", - "b29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuU2VjcmV0EhEKCXByaW5j", - "aXBhbBgCIAEoCRIbChNrcmI1X2NvbmZpZ19nY3NfdXJpGAMgASgJIikKBlNl", - "Y3JldBIWCgxjbG91ZF9zZWNyZXQYAiABKAlIAEIHCgV2YWx1ZSKPBgoOTWV0", - "YWRhdGFJbXBvcnQSEQoEbmFtZRgBIAEoCUID4EEFEhMKC2Rlc2NyaXB0aW9u", - "GAIgASgJEjQKC2NyZWF0ZV90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVm", - "LlRpbWVzdGFtcEID4EEDEjQKC3VwZGF0ZV90aW1lGAQgASgLMhouZ29vZ2xl", - "LnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEkgKBXN0YXRlGAUgASgOMjQuZ29v", - "Z2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLk1ldGFkYXRhSW1wb3J0LlN0", - "YXRlQgPgQQMSWQoNZGF0YWJhc2VfZHVtcBgGIAEoCzI7Lmdvb2dsZS5jbG91", - "ZC5tZXRhc3RvcmUudjFhbHBoYS5NZXRhZGF0YUltcG9ydC5EYXRhYmFzZUR1", - "bXBCA+BBBUgAGtMBCgxEYXRhYmFzZUR1bXASXwoNZGF0YWJhc2VfdHlwZRgB", - "IAEoDjJILmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5NZXRhZGF0", - "YUltcG9ydC5EYXRhYmFzZUR1bXAuRGF0YWJhc2VUeXBlEg8KB2djc191cmkY", - "AiABKAkSFwoPc291cmNlX2RhdGFiYXNlGAMgASgJIjgKDERhdGFiYXNlVHlw", - "ZRIdChlEQVRBQkFTRV9UWVBFX1VOU1BFQ0lGSUVEEAASCQoFTVlTUUwQASJU", - "CgVTdGF0ZRIVChFTVEFURV9VTlNQRUNJRklFRBAAEgsKB1JVTk5JTkcQARIN", - "CglTVUNDRUVERUQQAhIMCghVUERBVElORxADEgoKBkZBSUxFRBAEOosB6kGH", - "AQonbWV0YXN0b3JlLmdvb2dsZWFwaXMuY29tL01ldGFkYXRhSW1wb3J0Elxw", - "cm9qZWN0cy97cHJvamVjdH0vbG9jYXRpb25zL3tsb2NhdGlvbn0vc2Vydmlj", - "ZXMve3NlcnZpY2V9L21ldGFkYXRhSW1wb3J0cy97bWV0YWRhdGFfaW1wb3J0", - "fUIKCghtZXRhZGF0YSKtAQoTTGlzdFNlcnZpY2VzUmVxdWVzdBI5CgZwYXJl", - "bnQYASABKAlCKeBBAvpBIwohbG9jYXRpb25zLmdvb2dsZWFwaXMuY29tL0xv", - "Y2F0aW9uEhYKCXBhZ2Vfc2l6ZRgCIAEoBUID4EEBEhcKCnBhZ2VfdG9rZW4Y", - "AyABKAlCA+BBARITCgZmaWx0ZXIYBCABKAlCA+BBARIVCghvcmRlcl9ieRgF", - "IAEoCUID4EEBIn8KFExpc3RTZXJ2aWNlc1Jlc3BvbnNlEjkKCHNlcnZpY2Vz", - "GAEgAygLMicuZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLlNlcnZp", - "Y2USFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJEhMKC3VucmVhY2hhYmxlGAMg", - "AygJIksKEUdldFNlcnZpY2VSZXF1ZXN0EjYKBG5hbWUYASABKAlCKOBBAvpB", - "IgogbWV0YXN0b3JlLmdvb2dsZWFwaXMuY29tL1NlcnZpY2UiwgEKFENyZWF0", - "ZVNlcnZpY2VSZXF1ZXN0EjkKBnBhcmVudBgBIAEoCUIp4EEC+kEjCiFsb2Nh", - "dGlvbnMuZ29vZ2xlYXBpcy5jb20vTG9jYXRpb24SFwoKc2VydmljZV9pZBgC", - "IAEoCUID4EECEj0KB3NlcnZpY2UYAyABKAsyJy5nb29nbGUuY2xvdWQubWV0", - "YXN0b3JlLnYxYWxwaGEuU2VydmljZUID4EECEhcKCnJlcXVlc3RfaWQYBCAB", - "KAlCA+BBASKkAQoUVXBkYXRlU2VydmljZVJlcXVlc3QSNAoLdXBkYXRlX21h", - "c2sYASABKAsyGi5nb29nbGUucHJvdG9idWYuRmllbGRNYXNrQgPgQQISPQoH", - "c2VydmljZRgCIAEoCzInLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBo", - "YS5TZXJ2aWNlQgPgQQISFwoKcmVxdWVzdF9pZBgDIAEoCUID4EEBImcKFERl", - "bGV0ZVNlcnZpY2VSZXF1ZXN0EjYKBG5hbWUYASABKAlCKOBBAvpBIgogbWV0", - "YXN0b3JlLmdvb2dsZWFwaXMuY29tL1NlcnZpY2USFwoKcmVxdWVzdF9pZBgC", - "IAEoCUID4EEBIrMBChpMaXN0TWV0YWRhdGFJbXBvcnRzUmVxdWVzdBI4CgZw", - "YXJlbnQYASABKAlCKOBBAvpBIgogbWV0YXN0b3JlLmdvb2dsZWFwaXMuY29t", - "L1NlcnZpY2USFgoJcGFnZV9zaXplGAIgASgFQgPgQQESFwoKcGFnZV90b2tl", - "bhgDIAEoCUID4EEBEhMKBmZpbHRlchgEIAEoCUID4EEBEhUKCG9yZGVyX2J5", - "GAUgASgJQgPgQQEilQEKG0xpc3RNZXRhZGF0YUltcG9ydHNSZXNwb25zZRJI", - "ChBtZXRhZGF0YV9pbXBvcnRzGAEgAygLMi4uZ29vZ2xlLmNsb3VkLm1ldGFz", - "dG9yZS52MWFscGhhLk1ldGFkYXRhSW1wb3J0EhcKD25leHRfcGFnZV90b2tl", - "bhgCIAEoCRITCgt1bnJlYWNoYWJsZRgDIAMoCSJZChhHZXRNZXRhZGF0YUlt", - "cG9ydFJlcXVlc3QSPQoEbmFtZRgBIAEoCUIv4EEC+kEpCidtZXRhc3RvcmUu", - "Z29vZ2xlYXBpcy5jb20vTWV0YWRhdGFJbXBvcnQi3wEKG0NyZWF0ZU1ldGFk", - "YXRhSW1wb3J0UmVxdWVzdBI4CgZwYXJlbnQYASABKAlCKOBBAvpBIgogbWV0", - "YXN0b3JlLmdvb2dsZWFwaXMuY29tL1NlcnZpY2USHwoSbWV0YWRhdGFfaW1w", - "b3J0X2lkGAIgASgJQgPgQQISTAoPbWV0YWRhdGFfaW1wb3J0GAMgASgLMi4u", - "Z29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLk1ldGFkYXRhSW1wb3J0", - "QgPgQQISFwoKcmVxdWVzdF9pZBgEIAEoCUID4EEBIroBChtVcGRhdGVNZXRh", - "ZGF0YUltcG9ydFJlcXVlc3QSNAoLdXBkYXRlX21hc2sYASABKAsyGi5nb29n", - "bGUucHJvdG9idWYuRmllbGRNYXNrQgPgQQISTAoPbWV0YWRhdGFfaW1wb3J0", - "GAIgASgLMi4uZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLk1ldGFk", - "YXRhSW1wb3J0QgPgQQISFwoKcmVxdWVzdF9pZBgDIAEoCUID4EEBIoACChFP", - "cGVyYXRpb25NZXRhZGF0YRI0CgtjcmVhdGVfdGltZRgBIAEoCzIaLmdvb2ds", - "ZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxIxCghlbmRfdGltZRgCIAEoCzIa", - "Lmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxITCgZ0YXJnZXQYAyAB", - "KAlCA+BBAxIRCgR2ZXJiGAQgASgJQgPgQQMSGwoOc3RhdHVzX21lc3NhZ2UY", - "BSABKAlCA+BBAxIjChZyZXF1ZXN0ZWRfY2FuY2VsbGF0aW9uGAYgASgIQgPg", - "QQMSGAoLYXBpX3ZlcnNpb24YByABKAlCA+BBAyLBAQoQTG9jYXRpb25NZXRh", - "ZGF0YRJwCiFzdXBwb3J0ZWRfaGl2ZV9tZXRhc3RvcmVfdmVyc2lvbnMYASAD", - "KAsyRS5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuTG9jYXRpb25N", - "ZXRhZGF0YS5IaXZlTWV0YXN0b3JlVmVyc2lvbho7ChRIaXZlTWV0YXN0b3Jl", - "VmVyc2lvbhIPCgd2ZXJzaW9uGAEgASgJEhIKCmlzX2RlZmF1bHQYAiABKAgy", - "+xAKEURhdGFwcm9jTWV0YXN0b3JlEr0BCgxMaXN0U2VydmljZXMSMy5nb29n", - "bGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuTGlzdFNlcnZpY2VzUmVxdWVz", - "dBo0Lmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5MaXN0U2Vydmlj", - "ZXNSZXNwb25zZSJCgtPkkwIzEjEvdjFhbHBoYS97cGFyZW50PXByb2plY3Rz", - "LyovbG9jYXRpb25zLyp9L3NlcnZpY2Vz2kEGcGFyZW50EqoBCgpHZXRTZXJ2", - "aWNlEjEuZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLkdldFNlcnZp", - "Y2VSZXF1ZXN0GicuZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLlNl", - "cnZpY2UiQILT5JMCMxIxL3YxYWxwaGEve25hbWU9cHJvamVjdHMvKi9sb2Nh", - "dGlvbnMvKi9zZXJ2aWNlcy8qfdpBBG5hbWUS4wEKDUNyZWF0ZVNlcnZpY2US", - "NC5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuQ3JlYXRlU2Vydmlj", - "ZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9uIn2C0+ST", - "AjwiMS92MWFscGhhL3twYXJlbnQ9cHJvamVjdHMvKi9sb2NhdGlvbnMvKn0v", - "c2VydmljZXM6B3NlcnZpY2XaQRlwYXJlbnQsc2VydmljZSxzZXJ2aWNlX2lk", - "ykEcCgdTZXJ2aWNlEhFPcGVyYXRpb25NZXRhZGF0YRLlAQoNVXBkYXRlU2Vy", - "dmljZRI0Lmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5VcGRhdGVT", - "ZXJ2aWNlUmVxdWVzdBodLmdvb2dsZS5sb25ncnVubmluZy5PcGVyYXRpb24i", - "f4LT5JMCRDI5L3YxYWxwaGEve3NlcnZpY2UubmFtZT1wcm9qZWN0cy8qL2xv", - "Y2F0aW9ucy8qL3NlcnZpY2VzLyp9OgdzZXJ2aWNl2kETc2VydmljZSx1cGRh", - "dGVfbWFza8pBHAoHU2VydmljZRIRT3BlcmF0aW9uTWV0YWRhdGES0wEKDURl", - "bGV0ZVNlcnZpY2USNC5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEu", - "RGVsZXRlU2VydmljZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3Bl", - "cmF0aW9uIm2C0+STAjMqMS92MWFscGhhL3tuYW1lPXByb2plY3RzLyovbG9j", - "YXRpb25zLyovc2VydmljZXMvKn3aQQRuYW1lykEqChVnb29nbGUucHJvdG9i", - "dWYuRW1wdHkSEU9wZXJhdGlvbk1ldGFkYXRhEuQBChNMaXN0TWV0YWRhdGFJ", - "bXBvcnRzEjouZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLkxpc3RN", - "ZXRhZGF0YUltcG9ydHNSZXF1ZXN0GjsuZ29vZ2xlLmNsb3VkLm1ldGFzdG9y", - "ZS52MWFscGhhLkxpc3RNZXRhZGF0YUltcG9ydHNSZXNwb25zZSJUgtPkkwJF", - "EkMvdjFhbHBoYS97cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25zLyovc2Vy", - "dmljZXMvKn0vbWV0YWRhdGFJbXBvcnRz2kEGcGFyZW50EtEBChFHZXRNZXRh", - "ZGF0YUltcG9ydBI4Lmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5H", - "ZXRNZXRhZGF0YUltcG9ydFJlcXVlc3QaLi5nb29nbGUuY2xvdWQubWV0YXN0", - "b3JlLnYxYWxwaGEuTWV0YWRhdGFJbXBvcnQiUoLT5JMCRRJDL3YxYWxwaGEv", - "e25hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi9zZXJ2aWNlcy8qL21ldGFk", - "YXRhSW1wb3J0cy8qfdpBBG5hbWUSowIKFENyZWF0ZU1ldGFkYXRhSW1wb3J0", - "EjsuZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLkNyZWF0ZU1ldGFk", - "YXRhSW1wb3J0UmVxdWVzdBodLmdvb2dsZS5sb25ncnVubmluZy5PcGVyYXRp", - "b24irgGC0+STAlYiQy92MWFscGhhL3twYXJlbnQ9cHJvamVjdHMvKi9sb2Nh", - "dGlvbnMvKi9zZXJ2aWNlcy8qfS9tZXRhZGF0YUltcG9ydHM6D21ldGFkYXRh", - "X2ltcG9ydNpBKXBhcmVudCxtZXRhZGF0YV9pbXBvcnQsbWV0YWRhdGFfaW1w", - "b3J0X2lkykEjCg5NZXRhZGF0YUltcG9ydBIRT3BlcmF0aW9uTWV0YWRhdGES", - "pQIKFFVwZGF0ZU1ldGFkYXRhSW1wb3J0EjsuZ29vZ2xlLmNsb3VkLm1ldGFz", - "dG9yZS52MWFscGhhLlVwZGF0ZU1ldGFkYXRhSW1wb3J0UmVxdWVzdBodLmdv", - "b2dsZS5sb25ncnVubmluZy5PcGVyYXRpb24isAGC0+STAmYyUy92MWFscGhh", - "L3ttZXRhZGF0YV9pbXBvcnQubmFtZT1wcm9qZWN0cy8qL2xvY2F0aW9ucy8q", - "L3NlcnZpY2VzLyovbWV0YWRhdGFJbXBvcnRzLyp9Og9tZXRhZGF0YV9pbXBv", - "cnTaQRttZXRhZGF0YV9pbXBvcnQsdXBkYXRlX21hc2vKQSMKDk1ldGFkYXRh", - "SW1wb3J0EhFPcGVyYXRpb25NZXRhZGF0YRpMykEYbWV0YXN0b3JlLmdvb2ds", - "ZWFwaXMuY29t0kEuaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9j", - "bG91ZC1wbGF0Zm9ybULQAQoiY29tLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUu", - "djFhbHBoYUIOTWV0YXN0b3JlUHJvdG9QAVpHZ29vZ2xlLmdvbGFuZy5vcmcv", - "Z2VucHJvdG8vZ29vZ2xlYXBpcy9jbG91ZC9tZXRhc3RvcmUvdjFhbHBoYTtt", - "ZXRhc3RvcmXqQU4KHmNvbXB1dGUuZ29vZ2xlYXBpcy5jb20vTmV0d29yaxIs", - "cHJvamVjdHMve3Byb2plY3R9L2dsb2JhbC9uZXR3b3Jrcy97bmV0d29ya31i", - "BnByb3RvMw==")); + "Q29uZmlnSAASEQoEbmFtZRgBIAEoCUID4EEFEjQKC2NyZWF0ZV90aW1lGAIg", + "ASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEjQKC3VwZGF0", + "ZV90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EED", + "EkMKBmxhYmVscxgEIAMoCzIzLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFh", + "bHBoYS5TZXJ2aWNlLkxhYmVsc0VudHJ5EjcKB25ldHdvcmsYByABKAlCJuBB", + "BfpBIAoeY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9OZXR3b3JrEhkKDGVuZHBv", + "aW50X3VyaRgIIAEoCUID4EEDEgwKBHBvcnQYCSABKAUSQQoFc3RhdGUYCiAB", + "KA4yLS5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuU2VydmljZS5T", + "dGF0ZUID4EEDEhoKDXN0YXRlX21lc3NhZ2UYCyABKAlCA+BBAxIdChBhcnRp", + "ZmFjdF9nY3NfdXJpGAwgASgJQgPgQQMSOgoEdGllchgNIAEoDjIsLmdvb2ds", + "ZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5TZXJ2aWNlLlRpZXISUQoUbWV0", + "YWRhdGFfaW50ZWdyYXRpb24YDiABKAsyMy5nb29nbGUuY2xvdWQubWV0YXN0", + "b3JlLnYxYWxwaGEuTWV0YWRhdGFJbnRlZ3JhdGlvbhJNChJtYWludGVuYW5j", + "ZV93aW5kb3cYDyABKAsyMS5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxw", + "aGEuTWFpbnRlbmFuY2VXaW5kb3cSEAoDdWlkGBAgASgJQgPgQQMSZQocbWV0", + "YWRhdGFfbWFuYWdlbWVudF9hY3Rpdml0eRgRIAEoCzI6Lmdvb2dsZS5jbG91", + "ZC5tZXRhc3RvcmUudjFhbHBoYS5NZXRhZGF0YU1hbmFnZW1lbnRBY3Rpdml0", + "eUID4EEDGi0KC0xhYmVsc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgC", + "IAEoCToCOAEifgoFU3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIMCghD", + "UkVBVElORxABEgoKBkFDVElWRRACEg4KClNVU1BFTkRJTkcQAxINCglTVVNQ", + "RU5ERUQQBBIMCghVUERBVElORxAFEgwKCERFTEVUSU5HEAYSCQoFRVJST1IQ", + "ByI7CgRUaWVyEhQKEFRJRVJfVU5TUEVDSUZJRUQQABINCglERVZFTE9QRVIQ", + "ARIOCgpFTlRFUlBSSVNFEAM6YepBXgogbWV0YXN0b3JlLmdvb2dsZWFwaXMu", + "Y29tL1NlcnZpY2USOnByb2plY3RzL3twcm9qZWN0fS9sb2NhdGlvbnMve2xv", + "Y2F0aW9ufS9zZXJ2aWNlcy97c2VydmljZX1CEgoQbWV0YXN0b3JlX2NvbmZp", + "ZyJlChNNZXRhZGF0YUludGVncmF0aW9uEk4KE2RhdGFfY2F0YWxvZ19jb25m", + "aWcYASABKAsyMS5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuRGF0", + "YUNhdGFsb2dDb25maWciJAoRRGF0YUNhdGFsb2dDb25maWcSDwoHZW5hYmxl", + "ZBgBIAEoCCJyChFNYWludGVuYW5jZVdpbmRvdxIwCgtob3VyX29mX2RheRgB", + "IAEoCzIbLmdvb2dsZS5wcm90b2J1Zi5JbnQzMlZhbHVlEisKC2RheV9vZl93", + "ZWVrGAIgASgOMhYuZ29vZ2xlLnR5cGUuRGF5T2ZXZWVrIpACChNIaXZlTWV0", + "YXN0b3JlQ29uZmlnEhQKB3ZlcnNpb24YASABKAlCA+BBBRJiChBjb25maWdf", + "b3ZlcnJpZGVzGAIgAygLMkguZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFs", + "cGhhLkhpdmVNZXRhc3RvcmVDb25maWcuQ29uZmlnT3ZlcnJpZGVzRW50cnkS", + "RwoPa2VyYmVyb3NfY29uZmlnGAMgASgLMi4uZ29vZ2xlLmNsb3VkLm1ldGFz", + "dG9yZS52MWFscGhhLktlcmJlcm9zQ29uZmlnGjYKFENvbmZpZ092ZXJyaWRl", + "c0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEieAoOS2Vy", + "YmVyb3NDb25maWcSNgoGa2V5dGFiGAEgASgLMiYuZ29vZ2xlLmNsb3VkLm1l", + "dGFzdG9yZS52MWFscGhhLlNlY3JldBIRCglwcmluY2lwYWwYAiABKAkSGwoT", + "a3JiNV9jb25maWdfZ2NzX3VyaRgDIAEoCSIpCgZTZWNyZXQSFgoMY2xvdWRf", + "c2VjcmV0GAIgASgJSABCBwoFdmFsdWUiqwEKGk1ldGFkYXRhTWFuYWdlbWVu", + "dEFjdGl2aXR5Ek0KEG1ldGFkYXRhX2V4cG9ydHMYASADKAsyLi5nb29nbGUu", + "Y2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuTWV0YWRhdGFFeHBvcnRCA+BBAxI+", + "CghyZXN0b3JlcxgCIAMoCzInLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFh", + "bHBoYS5SZXN0b3JlQgPgQQMi4QYKDk1ldGFkYXRhSW1wb3J0ElkKDWRhdGFi", + "YXNlX2R1bXAYBiABKAsyOy5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxw", + "aGEuTWV0YWRhdGFJbXBvcnQuRGF0YWJhc2VEdW1wQgPgQQVIABIRCgRuYW1l", + "GAEgASgJQgPgQQUSEwoLZGVzY3JpcHRpb24YAiABKAkSNAoLY3JlYXRlX3Rp", + "bWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSNAoL", + "dXBkYXRlX3RpbWUYBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1w", + "QgPgQQMSSAoFc3RhdGUYBSABKA4yNC5nb29nbGUuY2xvdWQubWV0YXN0b3Jl", + "LnYxYWxwaGEuTWV0YWRhdGFJbXBvcnQuU3RhdGVCA+BBAxqlAgoMRGF0YWJh", + "c2VEdW1wEmMKDWRhdGFiYXNlX3R5cGUYASABKA4ySC5nb29nbGUuY2xvdWQu", + "bWV0YXN0b3JlLnYxYWxwaGEuTWV0YWRhdGFJbXBvcnQuRGF0YWJhc2VEdW1w", + "LkRhdGFiYXNlVHlwZUICGAESDwoHZ2NzX3VyaRgCIAEoCRIbCg9zb3VyY2Vf", + "ZGF0YWJhc2UYAyABKAlCAhgBEkgKBHR5cGUYBCABKA4yNS5nb29nbGUuY2xv", + "dWQubWV0YXN0b3JlLnYxYWxwaGEuRGF0YWJhc2VEdW1wU3BlYy5UeXBlQgPg", + "QQEiOAoMRGF0YWJhc2VUeXBlEh0KGURBVEFCQVNFX1RZUEVfVU5TUEVDSUZJ", + "RUQQABIJCgVNWVNRTBABIlQKBVN0YXRlEhUKEVNUQVRFX1VOU1BFQ0lGSUVE", + "EAASCwoHUlVOTklORxABEg0KCVNVQ0NFRURFRBACEgwKCFVQREFUSU5HEAMS", + "CgoGRkFJTEVEEAQ6iwHqQYcBCidtZXRhc3RvcmUuZ29vZ2xlYXBpcy5jb20v", + "TWV0YWRhdGFJbXBvcnQSXHByb2plY3RzL3twcm9qZWN0fS9sb2NhdGlvbnMv", + "e2xvY2F0aW9ufS9zZXJ2aWNlcy97c2VydmljZX0vbWV0YWRhdGFJbXBvcnRz", + "L3ttZXRhZGF0YV9pbXBvcnR9QgoKCG1ldGFkYXRhIqQDCg5NZXRhZGF0YUV4", + "cG9ydBIiChNkZXN0aW5hdGlvbl9nY3NfdXJpGAQgASgJQgPgQQNIABIzCgpz", + "dGFydF90aW1lGAEgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID", + "4EEDEjEKCGVuZF90aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVz", + "dGFtcEID4EEDEkgKBXN0YXRlGAMgASgOMjQuZ29vZ2xlLmNsb3VkLm1ldGFz", + "dG9yZS52MWFscGhhLk1ldGFkYXRhRXhwb3J0LlN0YXRlQgPgQQMSVgoSZGF0", + "YWJhc2VfZHVtcF90eXBlGAUgASgOMjUuZ29vZ2xlLmNsb3VkLm1ldGFzdG9y", + "ZS52MWFscGhhLkRhdGFiYXNlRHVtcFNwZWMuVHlwZUID4EEDIlUKBVN0YXRl", + "EhUKEVNUQVRFX1VOU1BFQ0lGSUVEEAASCwoHUlVOTklORxABEg0KCVNVQ0NF", + "RURFRBACEgoKBkZBSUxFRBADEg0KCUNBTkNFTExFRBAEQg0KC2Rlc3RpbmF0", + "aW9uIuoDCgZCYWNrdXASEQoEbmFtZRgBIAEoCUID4EEFEjQKC2NyZWF0ZV90", + "aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEjEK", + "CGVuZF90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID", + "4EEDEkAKBXN0YXRlGAQgASgOMiwuZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52", + "MWFscGhhLkJhY2t1cC5TdGF0ZUID4EEDEkYKEHNlcnZpY2VfcmV2aXNpb24Y", + "BSABKAsyJy5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuU2Vydmlj", + "ZUID4EEDEhMKC2Rlc2NyaXB0aW9uGAYgASgJIlIKBVN0YXRlEhUKEVNUQVRF", + "X1VOU1BFQ0lGSUVEEAASDAoIQ1JFQVRJTkcQARIMCghERUxFVElORxACEgoK", + "BkFDVElWRRADEgoKBkZBSUxFRBAEOnHqQW4KH21ldGFzdG9yZS5nb29nbGVh", + "cGlzLmNvbS9CYWNrdXASS3Byb2plY3RzL3twcm9qZWN0fS9sb2NhdGlvbnMv", + "e2xvY2F0aW9ufS9zZXJ2aWNlcy97c2VydmljZX0vYmFja3Vwcy97YmFja3Vw", + "fSLsAwoHUmVzdG9yZRIzCgpzdGFydF90aW1lGAEgASgLMhouZ29vZ2xlLnBy", + "b3RvYnVmLlRpbWVzdGFtcEID4EEDEjEKCGVuZF90aW1lGAIgASgLMhouZ29v", + "Z2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEkEKBXN0YXRlGAMgASgOMi0u", + "Z29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLlJlc3RvcmUuU3RhdGVC", + "A+BBAxI3CgZiYWNrdXAYBCABKAlCJ+BBA/pBIQofbWV0YXN0b3JlLmdvb2ds", + "ZWFwaXMuY29tL0JhY2t1cBJGCgR0eXBlGAUgASgOMjMuZ29vZ2xlLmNsb3Vk", + "Lm1ldGFzdG9yZS52MWFscGhhLlJlc3RvcmUuUmVzdG9yZVR5cGVCA+BBAxIU", + "CgdkZXRhaWxzGAYgASgJQgPgQQMiVQoFU3RhdGUSFQoRU1RBVEVfVU5TUEVD", + "SUZJRUQQABILCgdSVU5OSU5HEAESDQoJU1VDQ0VFREVEEAISCgoGRkFJTEVE", + "EAMSDQoJQ0FOQ0VMTEVEEAQiSAoLUmVzdG9yZVR5cGUSHAoYUkVTVE9SRV9U", + "WVBFX1VOU1BFQ0lGSUVEEAASCAoERlVMTBABEhEKDU1FVEFEQVRBX09OTFkQ", + "AiKtAQoTTGlzdFNlcnZpY2VzUmVxdWVzdBI5CgZwYXJlbnQYASABKAlCKeBB", + "AvpBIwohbG9jYXRpb25zLmdvb2dsZWFwaXMuY29tL0xvY2F0aW9uEhYKCXBh", + "Z2Vfc2l6ZRgCIAEoBUID4EEBEhcKCnBhZ2VfdG9rZW4YAyABKAlCA+BBARIT", + "CgZmaWx0ZXIYBCABKAlCA+BBARIVCghvcmRlcl9ieRgFIAEoCUID4EEBIn8K", + "FExpc3RTZXJ2aWNlc1Jlc3BvbnNlEjkKCHNlcnZpY2VzGAEgAygLMicuZ29v", + "Z2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLlNlcnZpY2USFwoPbmV4dF9w", + "YWdlX3Rva2VuGAIgASgJEhMKC3VucmVhY2hhYmxlGAMgAygJIksKEUdldFNl", + "cnZpY2VSZXF1ZXN0EjYKBG5hbWUYASABKAlCKOBBAvpBIgogbWV0YXN0b3Jl", + "Lmdvb2dsZWFwaXMuY29tL1NlcnZpY2UiwgEKFENyZWF0ZVNlcnZpY2VSZXF1", + "ZXN0EjkKBnBhcmVudBgBIAEoCUIp4EEC+kEjCiFsb2NhdGlvbnMuZ29vZ2xl", + "YXBpcy5jb20vTG9jYXRpb24SFwoKc2VydmljZV9pZBgCIAEoCUID4EECEj0K", + "B3NlcnZpY2UYAyABKAsyJy5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxw", + "aGEuU2VydmljZUID4EECEhcKCnJlcXVlc3RfaWQYBCABKAlCA+BBASKkAQoU", + "VXBkYXRlU2VydmljZVJlcXVlc3QSNAoLdXBkYXRlX21hc2sYASABKAsyGi5n", + "b29nbGUucHJvdG9idWYuRmllbGRNYXNrQgPgQQISPQoHc2VydmljZRgCIAEo", + "CzInLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5TZXJ2aWNlQgPg", + "QQISFwoKcmVxdWVzdF9pZBgDIAEoCUID4EEBImcKFERlbGV0ZVNlcnZpY2VS", + "ZXF1ZXN0EjYKBG5hbWUYASABKAlCKOBBAvpBIgogbWV0YXN0b3JlLmdvb2ds", + "ZWFwaXMuY29tL1NlcnZpY2USFwoKcmVxdWVzdF9pZBgCIAEoCUID4EEBIrMB", + "ChpMaXN0TWV0YWRhdGFJbXBvcnRzUmVxdWVzdBI4CgZwYXJlbnQYASABKAlC", + "KOBBAvpBIgogbWV0YXN0b3JlLmdvb2dsZWFwaXMuY29tL1NlcnZpY2USFgoJ", + "cGFnZV9zaXplGAIgASgFQgPgQQESFwoKcGFnZV90b2tlbhgDIAEoCUID4EEB", + "EhMKBmZpbHRlchgEIAEoCUID4EEBEhUKCG9yZGVyX2J5GAUgASgJQgPgQQEi", + "lQEKG0xpc3RNZXRhZGF0YUltcG9ydHNSZXNwb25zZRJIChBtZXRhZGF0YV9p", + "bXBvcnRzGAEgAygLMi4uZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhh", + "Lk1ldGFkYXRhSW1wb3J0EhcKD25leHRfcGFnZV90b2tlbhgCIAEoCRITCgt1", + "bnJlYWNoYWJsZRgDIAMoCSJZChhHZXRNZXRhZGF0YUltcG9ydFJlcXVlc3QS", + "PQoEbmFtZRgBIAEoCUIv4EEC+kEpCidtZXRhc3RvcmUuZ29vZ2xlYXBpcy5j", + "b20vTWV0YWRhdGFJbXBvcnQi3wEKG0NyZWF0ZU1ldGFkYXRhSW1wb3J0UmVx", + "dWVzdBI4CgZwYXJlbnQYASABKAlCKOBBAvpBIgogbWV0YXN0b3JlLmdvb2ds", + "ZWFwaXMuY29tL1NlcnZpY2USHwoSbWV0YWRhdGFfaW1wb3J0X2lkGAIgASgJ", + "QgPgQQISTAoPbWV0YWRhdGFfaW1wb3J0GAMgASgLMi4uZ29vZ2xlLmNsb3Vk", + "Lm1ldGFzdG9yZS52MWFscGhhLk1ldGFkYXRhSW1wb3J0QgPgQQISFwoKcmVx", + "dWVzdF9pZBgEIAEoCUID4EEBIroBChtVcGRhdGVNZXRhZGF0YUltcG9ydFJl", + "cXVlc3QSNAoLdXBkYXRlX21hc2sYASABKAsyGi5nb29nbGUucHJvdG9idWYu", + "RmllbGRNYXNrQgPgQQISTAoPbWV0YWRhdGFfaW1wb3J0GAIgASgLMi4uZ29v", + "Z2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLk1ldGFkYXRhSW1wb3J0QgPg", + "QQISFwoKcmVxdWVzdF9pZBgDIAEoCUID4EEBIqsBChJMaXN0QmFja3Vwc1Jl", + "cXVlc3QSOAoGcGFyZW50GAEgASgJQijgQQL6QSIKIG1ldGFzdG9yZS5nb29n", + "bGVhcGlzLmNvbS9TZXJ2aWNlEhYKCXBhZ2Vfc2l6ZRgCIAEoBUID4EEBEhcK", + "CnBhZ2VfdG9rZW4YAyABKAlCA+BBARITCgZmaWx0ZXIYBCABKAlCA+BBARIV", + "CghvcmRlcl9ieRgFIAEoCUID4EEBInwKE0xpc3RCYWNrdXBzUmVzcG9uc2US", + "NwoHYmFja3VwcxgBIAMoCzImLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFh", + "bHBoYS5CYWNrdXASFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJEhMKC3VucmVh", + "Y2hhYmxlGAMgAygJIkkKEEdldEJhY2t1cFJlcXVlc3QSNQoEbmFtZRgBIAEo", + "CUIn4EEC+kEhCh9tZXRhc3RvcmUuZ29vZ2xlYXBpcy5jb20vQmFja3VwIr0B", + "ChNDcmVhdGVCYWNrdXBSZXF1ZXN0EjgKBnBhcmVudBgBIAEoCUIo4EEC+kEi", + "CiBtZXRhc3RvcmUuZ29vZ2xlYXBpcy5jb20vU2VydmljZRIWCgliYWNrdXBf", + "aWQYAiABKAlCA+BBAhI7CgZiYWNrdXAYAyABKAsyJi5nb29nbGUuY2xvdWQu", + "bWV0YXN0b3JlLnYxYWxwaGEuQmFja3VwQgPgQQISFwoKcmVxdWVzdF9pZBgE", + "IAEoCUID4EEBImUKE0RlbGV0ZUJhY2t1cFJlcXVlc3QSNQoEbmFtZRgBIAEo", + "CUIn4EEC+kEhCh9tZXRhc3RvcmUuZ29vZ2xlYXBpcy5jb20vQmFja3VwEhcK", + "CnJlcXVlc3RfaWQYAiABKAlCA+BBASL0AQoVRXhwb3J0TWV0YWRhdGFSZXF1", + "ZXN0EiAKFmRlc3RpbmF0aW9uX2djc19mb2xkZXIYAiABKAlIABI5CgdzZXJ2", + "aWNlGAEgASgJQijgQQL6QSIKIG1ldGFzdG9yZS5nb29nbGVhcGlzLmNvbS9T", + "ZXJ2aWNlEhcKCnJlcXVlc3RfaWQYAyABKAlCA+BBARJWChJkYXRhYmFzZV9k", + "dW1wX3R5cGUYBCABKA4yNS5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxw", + "aGEuRGF0YWJhc2VEdW1wU3BlYy5UeXBlQgPgQQFCDQoLZGVzdGluYXRpb24i", + "9AEKFVJlc3RvcmVTZXJ2aWNlUmVxdWVzdBI5CgdzZXJ2aWNlGAEgASgJQijg", + "QQL6QSIKIG1ldGFzdG9yZS5nb29nbGVhcGlzLmNvbS9TZXJ2aWNlEjcKBmJh", + "Y2t1cBgCIAEoCUIn4EEC+kEhCh9tZXRhc3RvcmUuZ29vZ2xlYXBpcy5jb20v", + "QmFja3VwEk4KDHJlc3RvcmVfdHlwZRgDIAEoDjIzLmdvb2dsZS5jbG91ZC5t", + "ZXRhc3RvcmUudjFhbHBoYS5SZXN0b3JlLlJlc3RvcmVUeXBlQgPgQQESFwoK", + "cmVxdWVzdF9pZBgEIAEoCUID4EEBIoACChFPcGVyYXRpb25NZXRhZGF0YRI0", + "CgtjcmVhdGVfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3Rh", + "bXBCA+BBAxIxCghlbmRfdGltZRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5U", + "aW1lc3RhbXBCA+BBAxITCgZ0YXJnZXQYAyABKAlCA+BBAxIRCgR2ZXJiGAQg", + "ASgJQgPgQQMSGwoOc3RhdHVzX21lc3NhZ2UYBSABKAlCA+BBAxIjChZyZXF1", + "ZXN0ZWRfY2FuY2VsbGF0aW9uGAYgASgIQgPgQQMSGAoLYXBpX3ZlcnNpb24Y", + "ByABKAlCA+BBAyLBAQoQTG9jYXRpb25NZXRhZGF0YRJwCiFzdXBwb3J0ZWRf", + "aGl2ZV9tZXRhc3RvcmVfdmVyc2lvbnMYASADKAsyRS5nb29nbGUuY2xvdWQu", + "bWV0YXN0b3JlLnYxYWxwaGEuTG9jYXRpb25NZXRhZGF0YS5IaXZlTWV0YXN0", + "b3JlVmVyc2lvbho7ChRIaXZlTWV0YXN0b3JlVmVyc2lvbhIPCgd2ZXJzaW9u", + "GAEgASgJEhIKCmlzX2RlZmF1bHQYAiABKAgiOwoQRGF0YWJhc2VEdW1wU3Bl", + "YyInCgRUeXBlEhQKEFRZUEVfVU5TUEVDSUZJRUQQABIJCgVNWVNRTBABMoAb", + "ChFEYXRhcHJvY01ldGFzdG9yZRK9AQoMTGlzdFNlcnZpY2VzEjMuZ29vZ2xl", + "LmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLkxpc3RTZXJ2aWNlc1JlcXVlc3Qa", + "NC5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuTGlzdFNlcnZpY2Vz", + "UmVzcG9uc2UiQoLT5JMCMxIxL3YxYWxwaGEve3BhcmVudD1wcm9qZWN0cy8q", + "L2xvY2F0aW9ucy8qfS9zZXJ2aWNlc9pBBnBhcmVudBKqAQoKR2V0U2Vydmlj", + "ZRIxLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5HZXRTZXJ2aWNl", + "UmVxdWVzdBonLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5TZXJ2", + "aWNlIkCC0+STAjMSMS92MWFscGhhL3tuYW1lPXByb2plY3RzLyovbG9jYXRp", + "b25zLyovc2VydmljZXMvKn3aQQRuYW1lEuMBCg1DcmVhdGVTZXJ2aWNlEjQu", + "Z29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLkNyZWF0ZVNlcnZpY2VS", + "ZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdydW5uaW5nLk9wZXJhdGlvbiJ9gtPkkwI8", + "IjEvdjFhbHBoYS97cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25zLyp9L3Nl", + "cnZpY2VzOgdzZXJ2aWNl2kEZcGFyZW50LHNlcnZpY2Usc2VydmljZV9pZMpB", + "HAoHU2VydmljZRIRT3BlcmF0aW9uTWV0YWRhdGES5QEKDVVwZGF0ZVNlcnZp", + "Y2USNC5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuVXBkYXRlU2Vy", + "dmljZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9uIn+C", + "0+STAkQyOS92MWFscGhhL3tzZXJ2aWNlLm5hbWU9cHJvamVjdHMvKi9sb2Nh", + "dGlvbnMvKi9zZXJ2aWNlcy8qfToHc2VydmljZdpBE3NlcnZpY2UsdXBkYXRl", + "X21hc2vKQRwKB1NlcnZpY2USEU9wZXJhdGlvbk1ldGFkYXRhEtMBCg1EZWxl", + "dGVTZXJ2aWNlEjQuZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLkRl", + "bGV0ZVNlcnZpY2VSZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdydW5uaW5nLk9wZXJh", + "dGlvbiJtgtPkkwIzKjEvdjFhbHBoYS97bmFtZT1wcm9qZWN0cy8qL2xvY2F0", + "aW9ucy8qL3NlcnZpY2VzLyp92kEEbmFtZcpBKgoVZ29vZ2xlLnByb3RvYnVm", + "LkVtcHR5EhFPcGVyYXRpb25NZXRhZGF0YRLkAQoTTGlzdE1ldGFkYXRhSW1w", + "b3J0cxI6Lmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5MaXN0TWV0", + "YWRhdGFJbXBvcnRzUmVxdWVzdBo7Lmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUu", + "djFhbHBoYS5MaXN0TWV0YWRhdGFJbXBvcnRzUmVzcG9uc2UiVILT5JMCRRJD", + "L3YxYWxwaGEve3BhcmVudD1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qL3NlcnZp", + "Y2VzLyp9L21ldGFkYXRhSW1wb3J0c9pBBnBhcmVudBLRAQoRR2V0TWV0YWRh", + "dGFJbXBvcnQSOC5nb29nbGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuR2V0", + "TWV0YWRhdGFJbXBvcnRSZXF1ZXN0Gi4uZ29vZ2xlLmNsb3VkLm1ldGFzdG9y", + "ZS52MWFscGhhLk1ldGFkYXRhSW1wb3J0IlKC0+STAkUSQy92MWFscGhhL3tu", + "YW1lPXByb2plY3RzLyovbG9jYXRpb25zLyovc2VydmljZXMvKi9tZXRhZGF0", + "YUltcG9ydHMvKn3aQQRuYW1lEqMCChRDcmVhdGVNZXRhZGF0YUltcG9ydBI7", + "Lmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5DcmVhdGVNZXRhZGF0", + "YUltcG9ydFJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9u", + "Iq4BgtPkkwJWIkMvdjFhbHBoYS97cGFyZW50PXByb2plY3RzLyovbG9jYXRp", + "b25zLyovc2VydmljZXMvKn0vbWV0YWRhdGFJbXBvcnRzOg9tZXRhZGF0YV9p", + "bXBvcnTaQSlwYXJlbnQsbWV0YWRhdGFfaW1wb3J0LG1ldGFkYXRhX2ltcG9y", + "dF9pZMpBIwoOTWV0YWRhdGFJbXBvcnQSEU9wZXJhdGlvbk1ldGFkYXRhEqUC", + "ChRVcGRhdGVNZXRhZGF0YUltcG9ydBI7Lmdvb2dsZS5jbG91ZC5tZXRhc3Rv", + "cmUudjFhbHBoYS5VcGRhdGVNZXRhZGF0YUltcG9ydFJlcXVlc3QaHS5nb29n", + "bGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9uIrABgtPkkwJmMlMvdjFhbHBoYS97", + "bWV0YWRhdGFfaW1wb3J0Lm5hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi9z", + "ZXJ2aWNlcy8qL21ldGFkYXRhSW1wb3J0cy8qfToPbWV0YWRhdGFfaW1wb3J0", + "2kEbbWV0YWRhdGFfaW1wb3J0LHVwZGF0ZV9tYXNrykEjCg5NZXRhZGF0YUlt", + "cG9ydBIRT3BlcmF0aW9uTWV0YWRhdGES3AEKDkV4cG9ydE1ldGFkYXRhEjUu", + "Z29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLkV4cG9ydE1ldGFkYXRh", + "UmVxdWVzdBodLmdvb2dsZS5sb25ncnVubmluZy5PcGVyYXRpb24idILT5JMC", + "SCJDL3YxYWxwaGEve3NlcnZpY2U9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi9z", + "ZXJ2aWNlcy8qfTpleHBvcnRNZXRhZGF0YToBKspBIwoOTWV0YWRhdGFFeHBv", + "cnQSEU9wZXJhdGlvbk1ldGFkYXRhEt8BCg5SZXN0b3JlU2VydmljZRI1Lmdv", + "b2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5SZXN0b3JlU2VydmljZVJl", + "cXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9uIneC0+STAkEi", + "PC92MWFscGhhL3tzZXJ2aWNlPXByb2plY3RzLyovbG9jYXRpb25zLyovc2Vy", + "dmljZXMvKn06cmVzdG9yZToBKtpBDnNlcnZpY2UsYmFja3VwykEcCgdSZXN0", + "b3JlEhFPcGVyYXRpb25NZXRhZGF0YRLEAQoLTGlzdEJhY2t1cHMSMi5nb29n", + "bGUuY2xvdWQubWV0YXN0b3JlLnYxYWxwaGEuTGlzdEJhY2t1cHNSZXF1ZXN0", + "GjMuZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhLkxpc3RCYWNrdXBz", + "UmVzcG9uc2UiTILT5JMCPRI7L3YxYWxwaGEve3BhcmVudD1wcm9qZWN0cy8q", + "L2xvY2F0aW9ucy8qL3NlcnZpY2VzLyp9L2JhY2t1cHPaQQZwYXJlbnQSsQEK", + "CUdldEJhY2t1cBIwLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBoYS5H", + "ZXRCYWNrdXBSZXF1ZXN0GiYuZ29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFs", + "cGhhLkJhY2t1cCJKgtPkkwI9EjsvdjFhbHBoYS97bmFtZT1wcm9qZWN0cy8q", + "L2xvY2F0aW9ucy8qL3NlcnZpY2VzLyovYmFja3Vwcy8qfdpBBG5hbWUS6AEK", + "DENyZWF0ZUJhY2t1cBIzLmdvb2dsZS5jbG91ZC5tZXRhc3RvcmUudjFhbHBo", + "YS5DcmVhdGVCYWNrdXBSZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdydW5uaW5nLk9w", + "ZXJhdGlvbiKDAYLT5JMCRSI7L3YxYWxwaGEve3BhcmVudD1wcm9qZWN0cy8q", + "L2xvY2F0aW9ucy8qL3NlcnZpY2VzLyp9L2JhY2t1cHM6BmJhY2t1cNpBF3Bh", + "cmVudCxiYWNrdXAsYmFja3VwX2lkykEbCgZCYWNrdXASEU9wZXJhdGlvbk1l", + "dGFkYXRhEtsBCgxEZWxldGVCYWNrdXASMy5nb29nbGUuY2xvdWQubWV0YXN0", + "b3JlLnYxYWxwaGEuRGVsZXRlQmFja3VwUmVxdWVzdBodLmdvb2dsZS5sb25n", + "cnVubmluZy5PcGVyYXRpb24id4LT5JMCPSo7L3YxYWxwaGEve25hbWU9cHJv", + "amVjdHMvKi9sb2NhdGlvbnMvKi9zZXJ2aWNlcy8qL2JhY2t1cHMvKn3aQQRu", + "YW1lykEqChVnb29nbGUucHJvdG9idWYuRW1wdHkSEU9wZXJhdGlvbk1ldGFk", + "YXRhGkzKQRhtZXRhc3RvcmUuZ29vZ2xlYXBpcy5jb23SQS5odHRwczovL3d3", + "dy5nb29nbGVhcGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtQtABCiJjb20u", + "Z29vZ2xlLmNsb3VkLm1ldGFzdG9yZS52MWFscGhhQg5NZXRhc3RvcmVQcm90", + "b1ABWkdnb29nbGUuZ29sYW5nLm9yZy9nZW5wcm90by9nb29nbGVhcGlzL2Ns", + "b3VkL21ldGFzdG9yZS92MWFscGhhO21ldGFzdG9yZepBTgoeY29tcHV0ZS5n", + "b29nbGVhcGlzLmNvbS9OZXR3b3JrEixwcm9qZWN0cy97cHJvamVjdH0vZ2xv", + "YmFsL25ldHdvcmtzL3tuZXR3b3JrfWIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.LongRunning.OperationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, + new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.LongRunning.OperationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor, global::Google.Type.DayofweekReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.Service), global::Google.Cloud.Metastore.V1Alpha.Service.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "HiveMetastoreConfig", "Network", "EndpointUri", "Port", "State", "StateMessage", "ArtifactGcsUri", "Tier" }, new[]{ "MetastoreConfig" }, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.Service.Types.State), typeof(global::Google.Cloud.Metastore.V1Alpha.Service.Types.Tier) }, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.Service), global::Google.Cloud.Metastore.V1Alpha.Service.Parser, new[]{ "HiveMetastoreConfig", "Name", "CreateTime", "UpdateTime", "Labels", "Network", "EndpointUri", "Port", "State", "StateMessage", "ArtifactGcsUri", "Tier", "MetadataIntegration", "MaintenanceWindow", "Uid", "MetadataManagementActivity" }, new[]{ "MetastoreConfig" }, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.Service.Types.State), typeof(global::Google.Cloud.Metastore.V1Alpha.Service.Types.Tier) }, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataIntegration), global::Google.Cloud.Metastore.V1Alpha.MetadataIntegration.Parser, new[]{ "DataCatalogConfig" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.DataCatalogConfig), global::Google.Cloud.Metastore.V1Alpha.DataCatalogConfig.Parser, new[]{ "Enabled" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.MaintenanceWindow), global::Google.Cloud.Metastore.V1Alpha.MaintenanceWindow.Parser, new[]{ "HourOfDay", "DayOfWeek" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.HiveMetastoreConfig), global::Google.Cloud.Metastore.V1Alpha.HiveMetastoreConfig.Parser, new[]{ "Version", "ConfigOverrides", "KerberosConfig" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.KerberosConfig), global::Google.Cloud.Metastore.V1Alpha.KerberosConfig.Parser, new[]{ "Keytab", "Principal", "Krb5ConfigGcsUri" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.Secret), global::Google.Cloud.Metastore.V1Alpha.Secret.Parser, new[]{ "CloudSecret" }, new[]{ "Value" }, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataImport), global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Parser, new[]{ "Name", "Description", "CreateTime", "UpdateTime", "State", "DatabaseDump" }, new[]{ "Metadata" }, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump), global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Parser, new[]{ "DatabaseType", "GcsUri", "SourceDatabase" }, null, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType) }, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataManagementActivity), global::Google.Cloud.Metastore.V1Alpha.MetadataManagementActivity.Parser, new[]{ "MetadataExports", "Restores" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataImport), global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Parser, new[]{ "DatabaseDump", "Name", "Description", "CreateTime", "UpdateTime", "State" }, new[]{ "Metadata" }, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump), global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Parser, new[]{ "DatabaseType", "GcsUri", "SourceDatabase", "Type" }, null, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType) }, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataExport), global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Parser, new[]{ "DestinationGcsUri", "StartTime", "EndTime", "State", "DatabaseDumpType" }, new[]{ "Destination" }, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State) }, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.Backup), global::Google.Cloud.Metastore.V1Alpha.Backup.Parser, new[]{ "Name", "CreateTime", "EndTime", "State", "ServiceRevision", "Description" }, null, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State) }, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.Restore), global::Google.Cloud.Metastore.V1Alpha.Restore.Parser, new[]{ "StartTime", "EndTime", "State", "Backup", "Type", "Details" }, null, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State), typeof(global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType) }, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.ListServicesRequest), global::Google.Cloud.Metastore.V1Alpha.ListServicesRequest.Parser, new[]{ "Parent", "PageSize", "PageToken", "Filter", "OrderBy" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.ListServicesResponse), global::Google.Cloud.Metastore.V1Alpha.ListServicesResponse.Parser, new[]{ "Services", "NextPageToken", "Unreachable" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.GetServiceRequest), global::Google.Cloud.Metastore.V1Alpha.GetServiceRequest.Parser, new[]{ "Name" }, null, null, null, null), @@ -199,8 +312,16 @@ public static partial class MetastoreReflection { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.GetMetadataImportRequest), global::Google.Cloud.Metastore.V1Alpha.GetMetadataImportRequest.Parser, new[]{ "Name" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.CreateMetadataImportRequest), global::Google.Cloud.Metastore.V1Alpha.CreateMetadataImportRequest.Parser, new[]{ "Parent", "MetadataImportId", "MetadataImport", "RequestId" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.UpdateMetadataImportRequest), global::Google.Cloud.Metastore.V1Alpha.UpdateMetadataImportRequest.Parser, new[]{ "UpdateMask", "MetadataImport", "RequestId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.ListBackupsRequest), global::Google.Cloud.Metastore.V1Alpha.ListBackupsRequest.Parser, new[]{ "Parent", "PageSize", "PageToken", "Filter", "OrderBy" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.ListBackupsResponse), global::Google.Cloud.Metastore.V1Alpha.ListBackupsResponse.Parser, new[]{ "Backups", "NextPageToken", "Unreachable" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.GetBackupRequest), global::Google.Cloud.Metastore.V1Alpha.GetBackupRequest.Parser, new[]{ "Name" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.CreateBackupRequest), global::Google.Cloud.Metastore.V1Alpha.CreateBackupRequest.Parser, new[]{ "Parent", "BackupId", "Backup", "RequestId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.DeleteBackupRequest), global::Google.Cloud.Metastore.V1Alpha.DeleteBackupRequest.Parser, new[]{ "Name", "RequestId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.ExportMetadataRequest), global::Google.Cloud.Metastore.V1Alpha.ExportMetadataRequest.Parser, new[]{ "DestinationGcsFolder", "Service", "RequestId", "DatabaseDumpType" }, new[]{ "Destination" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.RestoreServiceRequest), global::Google.Cloud.Metastore.V1Alpha.RestoreServiceRequest.Parser, new[]{ "Service", "Backup", "RestoreType", "RequestId" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.OperationMetadata), global::Google.Cloud.Metastore.V1Alpha.OperationMetadata.Parser, new[]{ "CreateTime", "EndTime", "Target", "Verb", "StatusMessage", "RequestedCancellation", "ApiVersion" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.LocationMetadata), global::Google.Cloud.Metastore.V1Alpha.LocationMetadata.Parser, new[]{ "SupportedHiveMetastoreVersions" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.LocationMetadata.Types.HiveMetastoreVersion), global::Google.Cloud.Metastore.V1Alpha.LocationMetadata.Types.HiveMetastoreVersion.Parser, new[]{ "Version", "IsDefault" }, null, null, null, null)}) + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.LocationMetadata), global::Google.Cloud.Metastore.V1Alpha.LocationMetadata.Parser, new[]{ "SupportedHiveMetastoreVersions" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.LocationMetadata.Types.HiveMetastoreVersion), global::Google.Cloud.Metastore.V1Alpha.LocationMetadata.Types.HiveMetastoreVersion.Parser, new[]{ "Version", "IsDefault" }, null, null, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec), global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Parser, null, null, new[]{ typeof(global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type) }, null, null) })); } #endregion @@ -250,6 +371,10 @@ public sealed partial class Service : pb::IMessage stateMessage_ = other.stateMessage_; artifactGcsUri_ = other.artifactGcsUri_; tier_ = other.tier_; + metadataIntegration_ = other.metadataIntegration_ != null ? other.metadataIntegration_.Clone() : null; + maintenanceWindow_ = other.maintenanceWindow_ != null ? other.maintenanceWindow_.Clone() : null; + uid_ = other.uid_; + metadataManagementActivity_ = other.metadataManagementActivity_ != null ? other.metadataManagementActivity_.Clone() : null; switch (other.MetastoreConfigCase) { case MetastoreConfigOneofCase.HiveMetastoreConfig: HiveMetastoreConfig = other.HiveMetastoreConfig.Clone(); @@ -264,13 +389,28 @@ public sealed partial class Service : pb::IMessage return new Service(this); } + /// Field number for the "hive_metastore_config" field. + public const int HiveMetastoreConfigFieldNumber = 5; + /// + /// Configuration information specific to running Hive metastore + /// software as the metastore service. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.HiveMetastoreConfig HiveMetastoreConfig { + get { return metastoreConfigCase_ == MetastoreConfigOneofCase.HiveMetastoreConfig ? (global::Google.Cloud.Metastore.V1Alpha.HiveMetastoreConfig) metastoreConfig_ : null; } + set { + metastoreConfig_ = value; + metastoreConfigCase_ = value == null ? MetastoreConfigOneofCase.None : MetastoreConfigOneofCase.HiveMetastoreConfig; + } + } + /// Field number for the "name" field. public const int NameFieldNumber = 1; private string name_ = ""; /// /// Immutable. The relative resource name of the metastore service, of the form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public string Name { @@ -321,30 +461,14 @@ public sealed partial class Service : pb::IMessage get { return labels_; } } - /// Field number for the "hive_metastore_config" field. - public const int HiveMetastoreConfigFieldNumber = 5; - /// - /// Configuration information specific to running Hive metastore - /// software as the metastore service. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.HiveMetastoreConfig HiveMetastoreConfig { - get { return metastoreConfigCase_ == MetastoreConfigOneofCase.HiveMetastoreConfig ? (global::Google.Cloud.Metastore.V1Alpha.HiveMetastoreConfig) metastoreConfig_ : null; } - set { - metastoreConfig_ = value; - metastoreConfigCase_ = value == null ? MetastoreConfigOneofCase.None : MetastoreConfigOneofCase.HiveMetastoreConfig; - } - } - /// Field number for the "network" field. public const int NetworkFieldNumber = 7; private string network_ = ""; /// /// Immutable. The relative resource name of the VPC network on which the instance can be - /// accessed. The network must belong to the same project as the metastore - /// instance. It is specified in the following form: + /// accessed. It is specified in the following form: /// - /// "projects/{project_id}/global/networks/{network_id}". + /// `projects/{project_number}/global/networks/{network_id}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public string Network { @@ -440,6 +564,64 @@ public sealed partial class Service : pb::IMessage } } + /// Field number for the "metadata_integration" field. + public const int MetadataIntegrationFieldNumber = 14; + private global::Google.Cloud.Metastore.V1Alpha.MetadataIntegration metadataIntegration_; + /// + /// The setting that defines how metastore metadata should be integrated with + /// external services and systems. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.MetadataIntegration MetadataIntegration { + get { return metadataIntegration_; } + set { + metadataIntegration_ = value; + } + } + + /// Field number for the "maintenance_window" field. + public const int MaintenanceWindowFieldNumber = 15; + private global::Google.Cloud.Metastore.V1Alpha.MaintenanceWindow maintenanceWindow_; + /// + /// The one hour maintenance window of the metastore service. This specifies + /// when the service can be restarted for maintenance purposes in UTC time. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.MaintenanceWindow MaintenanceWindow { + get { return maintenanceWindow_; } + set { + maintenanceWindow_ = value; + } + } + + /// Field number for the "uid" field. + public const int UidFieldNumber = 16; + private string uid_ = ""; + /// + /// Output only. The globally unique resource identifier of the metastore service. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Uid { + get { return uid_; } + set { + uid_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "metadata_management_activity" field. + public const int MetadataManagementActivityFieldNumber = 17; + private global::Google.Cloud.Metastore.V1Alpha.MetadataManagementActivity metadataManagementActivity_; + /// + /// Output only. The metadata management activities of the metastore service. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.MetadataManagementActivity MetadataManagementActivity { + get { return metadataManagementActivity_; } + set { + metadataManagementActivity_ = value; + } + } + private object metastoreConfig_; /// Enum of possible cases for the "metastore_config" oneof. public enum MetastoreConfigOneofCase { @@ -471,11 +653,11 @@ public enum MetastoreConfigOneofCase { if (ReferenceEquals(other, this)) { return true; } + if (!object.Equals(HiveMetastoreConfig, other.HiveMetastoreConfig)) return false; if (Name != other.Name) return false; if (!object.Equals(CreateTime, other.CreateTime)) return false; if (!object.Equals(UpdateTime, other.UpdateTime)) return false; if (!Labels.Equals(other.Labels)) return false; - if (!object.Equals(HiveMetastoreConfig, other.HiveMetastoreConfig)) return false; if (Network != other.Network) return false; if (EndpointUri != other.EndpointUri) return false; if (Port != other.Port) return false; @@ -483,6 +665,10 @@ public enum MetastoreConfigOneofCase { if (StateMessage != other.StateMessage) return false; if (ArtifactGcsUri != other.ArtifactGcsUri) return false; if (Tier != other.Tier) return false; + if (!object.Equals(MetadataIntegration, other.MetadataIntegration)) return false; + if (!object.Equals(MaintenanceWindow, other.MaintenanceWindow)) return false; + if (Uid != other.Uid) return false; + if (!object.Equals(MetadataManagementActivity, other.MetadataManagementActivity)) return false; if (MetastoreConfigCase != other.MetastoreConfigCase) return false; return Equals(_unknownFields, other._unknownFields); } @@ -490,11 +676,11 @@ public enum MetastoreConfigOneofCase { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; + if (metastoreConfigCase_ == MetastoreConfigOneofCase.HiveMetastoreConfig) hash ^= HiveMetastoreConfig.GetHashCode(); if (Name.Length != 0) hash ^= Name.GetHashCode(); if (createTime_ != null) hash ^= CreateTime.GetHashCode(); if (updateTime_ != null) hash ^= UpdateTime.GetHashCode(); hash ^= Labels.GetHashCode(); - if (metastoreConfigCase_ == MetastoreConfigOneofCase.HiveMetastoreConfig) hash ^= HiveMetastoreConfig.GetHashCode(); if (Network.Length != 0) hash ^= Network.GetHashCode(); if (EndpointUri.Length != 0) hash ^= EndpointUri.GetHashCode(); if (Port != 0) hash ^= Port.GetHashCode(); @@ -502,6 +688,10 @@ public enum MetastoreConfigOneofCase { if (StateMessage.Length != 0) hash ^= StateMessage.GetHashCode(); if (ArtifactGcsUri.Length != 0) hash ^= ArtifactGcsUri.GetHashCode(); if (Tier != global::Google.Cloud.Metastore.V1Alpha.Service.Types.Tier.Unspecified) hash ^= Tier.GetHashCode(); + if (metadataIntegration_ != null) hash ^= MetadataIntegration.GetHashCode(); + if (maintenanceWindow_ != null) hash ^= MaintenanceWindow.GetHashCode(); + if (Uid.Length != 0) hash ^= Uid.GetHashCode(); + if (metadataManagementActivity_ != null) hash ^= MetadataManagementActivity.GetHashCode(); hash ^= (int) metastoreConfigCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); @@ -564,6 +754,22 @@ public enum MetastoreConfigOneofCase { output.WriteRawTag(104); output.WriteEnum((int) Tier); } + if (metadataIntegration_ != null) { + output.WriteRawTag(114); + output.WriteMessage(MetadataIntegration); + } + if (maintenanceWindow_ != null) { + output.WriteRawTag(122); + output.WriteMessage(MaintenanceWindow); + } + if (Uid.Length != 0) { + output.WriteRawTag(130, 1); + output.WriteString(Uid); + } + if (metadataManagementActivity_ != null) { + output.WriteRawTag(138, 1); + output.WriteMessage(MetadataManagementActivity); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -618,6 +824,22 @@ public enum MetastoreConfigOneofCase { output.WriteRawTag(104); output.WriteEnum((int) Tier); } + if (metadataIntegration_ != null) { + output.WriteRawTag(114); + output.WriteMessage(MetadataIntegration); + } + if (maintenanceWindow_ != null) { + output.WriteRawTag(122); + output.WriteMessage(MaintenanceWindow); + } + if (Uid.Length != 0) { + output.WriteRawTag(130, 1); + output.WriteString(Uid); + } + if (metadataManagementActivity_ != null) { + output.WriteRawTag(138, 1); + output.WriteMessage(MetadataManagementActivity); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -627,6 +849,9 @@ public enum MetastoreConfigOneofCase { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public int CalculateSize() { int size = 0; + if (metastoreConfigCase_ == MetastoreConfigOneofCase.HiveMetastoreConfig) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(HiveMetastoreConfig); + } if (Name.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); } @@ -637,9 +862,6 @@ public enum MetastoreConfigOneofCase { size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateTime); } size += labels_.CalculateSize(_map_labels_codec); - if (metastoreConfigCase_ == MetastoreConfigOneofCase.HiveMetastoreConfig) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(HiveMetastoreConfig); - } if (Network.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Network); } @@ -661,6 +883,18 @@ public enum MetastoreConfigOneofCase { if (Tier != global::Google.Cloud.Metastore.V1Alpha.Service.Types.Tier.Unspecified) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Tier); } + if (metadataIntegration_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(MetadataIntegration); + } + if (maintenanceWindow_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(MaintenanceWindow); + } + if (Uid.Length != 0) { + size += 2 + pb::CodedOutputStream.ComputeStringSize(Uid); + } + if (metadataManagementActivity_ != null) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(MetadataManagementActivity); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -709,6 +943,27 @@ public enum MetastoreConfigOneofCase { if (other.Tier != global::Google.Cloud.Metastore.V1Alpha.Service.Types.Tier.Unspecified) { Tier = other.Tier; } + if (other.metadataIntegration_ != null) { + if (metadataIntegration_ == null) { + MetadataIntegration = new global::Google.Cloud.Metastore.V1Alpha.MetadataIntegration(); + } + MetadataIntegration.MergeFrom(other.MetadataIntegration); + } + if (other.maintenanceWindow_ != null) { + if (maintenanceWindow_ == null) { + MaintenanceWindow = new global::Google.Cloud.Metastore.V1Alpha.MaintenanceWindow(); + } + MaintenanceWindow.MergeFrom(other.MaintenanceWindow); + } + if (other.Uid.Length != 0) { + Uid = other.Uid; + } + if (other.metadataManagementActivity_ != null) { + if (metadataManagementActivity_ == null) { + MetadataManagementActivity = new global::Google.Cloud.Metastore.V1Alpha.MetadataManagementActivity(); + } + MetadataManagementActivity.MergeFrom(other.MetadataManagementActivity); + } switch (other.MetastoreConfigCase) { case MetastoreConfigOneofCase.HiveMetastoreConfig: if (HiveMetastoreConfig == null) { @@ -791,6 +1046,31 @@ public enum MetastoreConfigOneofCase { Tier = (global::Google.Cloud.Metastore.V1Alpha.Service.Types.Tier) input.ReadEnum(); break; } + case 114: { + if (metadataIntegration_ == null) { + MetadataIntegration = new global::Google.Cloud.Metastore.V1Alpha.MetadataIntegration(); + } + input.ReadMessage(MetadataIntegration); + break; + } + case 122: { + if (maintenanceWindow_ == null) { + MaintenanceWindow = new global::Google.Cloud.Metastore.V1Alpha.MaintenanceWindow(); + } + input.ReadMessage(MaintenanceWindow); + break; + } + case 130: { + Uid = input.ReadString(); + break; + } + case 138: { + if (metadataManagementActivity_ == null) { + MetadataManagementActivity = new global::Google.Cloud.Metastore.V1Alpha.MetadataManagementActivity(); + } + input.ReadMessage(MetadataManagementActivity); + break; + } } } #endif @@ -864,6 +1144,31 @@ public enum MetastoreConfigOneofCase { Tier = (global::Google.Cloud.Metastore.V1Alpha.Service.Types.Tier) input.ReadEnum(); break; } + case 114: { + if (metadataIntegration_ == null) { + MetadataIntegration = new global::Google.Cloud.Metastore.V1Alpha.MetadataIntegration(); + } + input.ReadMessage(MetadataIntegration); + break; + } + case 122: { + if (maintenanceWindow_ == null) { + MaintenanceWindow = new global::Google.Cloud.Metastore.V1Alpha.MaintenanceWindow(); + } + input.ReadMessage(MaintenanceWindow); + break; + } + case 130: { + Uid = input.ReadString(); + break; + } + case 138: { + if (metadataManagementActivity_ == null) { + MetadataManagementActivity = new global::Google.Cloud.Metastore.V1Alpha.MetadataManagementActivity(); + } + input.ReadMessage(MetadataManagementActivity); + break; + } } } } @@ -923,8 +1228,13 @@ public enum Tier { /// [pbr::OriginalName("TIER_UNSPECIFIED")] Unspecified = 0, /// - /// The enterprise tier combines a powerful metastore serving layer with a - /// highly scalable data storage layer. + /// The developer tier provides limited scalability and no fault tolerance. + /// Good for low-cost proof-of-concept. + /// + [pbr::OriginalName("DEVELOPER")] Developer = 1, + /// + /// The enterprise tier provides multi-zone high availability, and sufficient + /// scalability for enterprise-level Dataproc Metastore workloads. /// [pbr::OriginalName("ENTERPRISE")] Enterprise = 3, } @@ -935,18 +1245,17 @@ public enum Tier { } /// - /// Specifies configuration information specific to running Hive metastore - /// software as the metastore service. + /// Specifies how metastore metadata should be integrated with external services. /// - public sealed partial class HiveMetastoreConfig : pb::IMessage + public sealed partial class MetadataIntegration : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new HiveMetastoreConfig()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MetadataIntegration()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { @@ -959,94 +1268,58 @@ public sealed partial class HiveMetastoreConfig : pb::IMessageField number for the "version" field. - public const int VersionFieldNumber = 1; - private string version_ = ""; - /// - /// Immutable. The Hive metastore schema version. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Version { - get { return version_; } - set { - version_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - - /// Field number for the "config_overrides" field. - public const int ConfigOverridesFieldNumber = 2; - private static readonly pbc::MapField.Codec _map_configOverrides_codec - = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 18); - private readonly pbc::MapField configOverrides_ = new pbc::MapField(); - /// - /// A mapping of Hive metastore configuration key-value pairs to apply to the - /// Hive metastore (configured in `hive-site.xml`). The mappings - /// override system defaults (some keys cannot be overridden). - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public pbc::MapField ConfigOverrides { - get { return configOverrides_; } + public MetadataIntegration Clone() { + return new MetadataIntegration(this); } - /// Field number for the "kerberos_config" field. - public const int KerberosConfigFieldNumber = 3; - private global::Google.Cloud.Metastore.V1Alpha.KerberosConfig kerberosConfig_; + /// Field number for the "data_catalog_config" field. + public const int DataCatalogConfigFieldNumber = 1; + private global::Google.Cloud.Metastore.V1Alpha.DataCatalogConfig dataCatalogConfig_; /// - /// Information used to configure the Hive metastore service as a service - /// principal in a Kerberos realm. + /// The integration config for the Data Catalog service. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.KerberosConfig KerberosConfig { - get { return kerberosConfig_; } + public global::Google.Cloud.Metastore.V1Alpha.DataCatalogConfig DataCatalogConfig { + get { return dataCatalogConfig_; } set { - kerberosConfig_ = value; + dataCatalogConfig_ = value; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as HiveMetastoreConfig); + return Equals(other as MetadataIntegration); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(HiveMetastoreConfig other) { + public bool Equals(MetadataIntegration other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Version != other.Version) return false; - if (!ConfigOverrides.Equals(other.ConfigOverrides)) return false; - if (!object.Equals(KerberosConfig, other.KerberosConfig)) return false; + if (!object.Equals(DataCatalogConfig, other.DataCatalogConfig)) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (Version.Length != 0) hash ^= Version.GetHashCode(); - hash ^= ConfigOverrides.GetHashCode(); - if (kerberosConfig_ != null) hash ^= KerberosConfig.GetHashCode(); + if (dataCatalogConfig_ != null) hash ^= DataCatalogConfig.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -1063,14 +1336,9 @@ public sealed partial class HiveMetastoreConfig : pb::IMessage - /// Configuration information for a Kerberos principal. + /// Specifies how metastore metadata should be integrated with the Data Catalog + /// service. /// - public sealed partial class KerberosConfig : pb::IMessage + public sealed partial class DataCatalogConfig : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new KerberosConfig()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DataCatalogConfig()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { @@ -1216,97 +1456,59 @@ public sealed partial class KerberosConfig : pb::IMessage } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public KerberosConfig() { + public DataCatalogConfig() { OnConstruction(); } partial void OnConstruction(); [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public KerberosConfig(KerberosConfig other) : this() { - keytab_ = other.keytab_ != null ? other.keytab_.Clone() : null; - principal_ = other.principal_; - krb5ConfigGcsUri_ = other.krb5ConfigGcsUri_; + public DataCatalogConfig(DataCatalogConfig other) : this() { + enabled_ = other.enabled_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public KerberosConfig Clone() { - return new KerberosConfig(this); + public DataCatalogConfig Clone() { + return new DataCatalogConfig(this); } - /// Field number for the "keytab" field. - public const int KeytabFieldNumber = 1; - private global::Google.Cloud.Metastore.V1Alpha.Secret keytab_; + /// Field number for the "enabled" field. + public const int EnabledFieldNumber = 1; + private bool enabled_; /// - /// A Kerberos keytab file that can be used to authenticate a service principal - /// with a Kerberos Key Distribution Center (KDC). + /// Defines whether the metastore metadata should be synced to Data Catalog. + /// The default value is to disable syncing metastore metadata to Data Catalog. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.Secret Keytab { - get { return keytab_; } + public bool Enabled { + get { return enabled_; } set { - keytab_ = value; + enabled_ = value; } } - /// Field number for the "principal" field. - public const int PrincipalFieldNumber = 2; - private string principal_ = ""; - /// - /// A Kerberos principal that exists in the both the keytab the KDC - /// to authenticate as. A typical principal is of the form - /// "primary/instance@REALM", but there is no exact format. - /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Principal { - get { return principal_; } - set { - principal_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - - /// Field number for the "krb5_config_gcs_uri" field. - public const int Krb5ConfigGcsUriFieldNumber = 3; - private string krb5ConfigGcsUri_ = ""; - /// - /// A Cloud Storage URI that specifies the path to a - /// krb5.conf file. It is of the form gs://{bucket_name}/path/to/krb5.conf, - /// although the file does not need to be named krb5.conf explicitly. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Krb5ConfigGcsUri { - get { return krb5ConfigGcsUri_; } - set { - krb5ConfigGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public override bool Equals(object other) { - return Equals(other as KerberosConfig); + public override bool Equals(object other) { + return Equals(other as DataCatalogConfig); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(KerberosConfig other) { + public bool Equals(DataCatalogConfig other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(Keytab, other.Keytab)) return false; - if (Principal != other.Principal) return false; - if (Krb5ConfigGcsUri != other.Krb5ConfigGcsUri) return false; + if (Enabled != other.Enabled) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (keytab_ != null) hash ^= Keytab.GetHashCode(); - if (Principal.Length != 0) hash ^= Principal.GetHashCode(); - if (Krb5ConfigGcsUri.Length != 0) hash ^= Krb5ConfigGcsUri.GetHashCode(); + if (Enabled != false) hash ^= Enabled.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -1323,17 +1525,9 @@ public sealed partial class KerberosConfig : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (keytab_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Keytab); - } - if (Principal.Length != 0) { - output.WriteRawTag(18); - output.WriteString(Principal); - } - if (Krb5ConfigGcsUri.Length != 0) { - output.WriteRawTag(26); - output.WriteString(Krb5ConfigGcsUri); + if (Enabled != false) { + output.WriteRawTag(8); + output.WriteBool(Enabled); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -1344,17 +1538,9 @@ public sealed partial class KerberosConfig : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE [global::System.Diagnostics.DebuggerNonUserCodeAttribute] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (keytab_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Keytab); - } - if (Principal.Length != 0) { - output.WriteRawTag(18); - output.WriteString(Principal); - } - if (Krb5ConfigGcsUri.Length != 0) { - output.WriteRawTag(26); - output.WriteString(Krb5ConfigGcsUri); + if (Enabled != false) { + output.WriteRawTag(8); + output.WriteBool(Enabled); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -1365,14 +1551,8 @@ public sealed partial class KerberosConfig : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public int CalculateSize() { int size = 0; - if (keytab_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Keytab); - } - if (Principal.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Principal); - } - if (Krb5ConfigGcsUri.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Krb5ConfigGcsUri); + if (Enabled != false) { + size += 1 + 1; } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -1381,21 +1561,12 @@ public sealed partial class KerberosConfig : pb::IMessage } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void MergeFrom(KerberosConfig other) { + public void MergeFrom(DataCatalogConfig other) { if (other == null) { return; } - if (other.keytab_ != null) { - if (keytab_ == null) { - Keytab = new global::Google.Cloud.Metastore.V1Alpha.Secret(); - } - Keytab.MergeFrom(other.Keytab); - } - if (other.Principal.Length != 0) { - Principal = other.Principal; - } - if (other.Krb5ConfigGcsUri.Length != 0) { - Krb5ConfigGcsUri = other.Krb5ConfigGcsUri; + if (other.Enabled != false) { + Enabled = other.Enabled; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -1411,19 +1582,8 @@ public sealed partial class KerberosConfig : pb::IMessage default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 10: { - if (keytab_ == null) { - Keytab = new global::Google.Cloud.Metastore.V1Alpha.Secret(); - } - input.ReadMessage(Keytab); - break; - } - case 18: { - Principal = input.ReadString(); - break; - } - case 26: { - Krb5ConfigGcsUri = input.ReadString(); + case 8: { + Enabled = input.ReadBool(); break; } } @@ -1440,19 +1600,8 @@ public sealed partial class KerberosConfig : pb::IMessage default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 10: { - if (keytab_ == null) { - Keytab = new global::Google.Cloud.Metastore.V1Alpha.Secret(); - } - input.ReadMessage(Keytab); - break; - } - case 18: { - Principal = input.ReadString(); - break; - } - case 26: { - Krb5ConfigGcsUri = input.ReadString(); + case 8: { + Enabled = input.ReadBool(); break; } } @@ -1463,17 +1612,18 @@ public sealed partial class KerberosConfig : pb::IMessage } /// - /// A securely stored value. + /// Maintenance window. This specifies when Dataproc Metastore + /// may perform system maintenance operation to the service. /// - public sealed partial class Secret : pb::IMessage + public sealed partial class MaintenanceWindow : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Secret()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MaintenanceWindow()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { @@ -1486,86 +1636,77 @@ public sealed partial class Secret : pb::IMessage } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public Secret() { + public MaintenanceWindow() { OnConstruction(); } partial void OnConstruction(); [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public Secret(Secret other) : this() { - switch (other.ValueCase) { - case ValueOneofCase.CloudSecret: - CloudSecret = other.CloudSecret; - break; - } - + public MaintenanceWindow(MaintenanceWindow other) : this() { + HourOfDay = other.HourOfDay; + dayOfWeek_ = other.dayOfWeek_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public Secret Clone() { - return new Secret(this); + public MaintenanceWindow Clone() { + return new MaintenanceWindow(this); } - /// Field number for the "cloud_secret" field. - public const int CloudSecretFieldNumber = 2; + /// Field number for the "hour_of_day" field. + public const int HourOfDayFieldNumber = 1; + private static readonly pb::FieldCodec _single_hourOfDay_codec = pb::FieldCodec.ForStructWrapper(10); + private int? hourOfDay_; /// - /// The relative resource name of a Secret Manager secret version, in the - /// following form: - /// - /// "projects/{project_id}/secrets/{secret_id}/versions/{version_id}". + /// The hour of day (0-23) when the window starts. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string CloudSecret { - get { return valueCase_ == ValueOneofCase.CloudSecret ? (string) value_ : ""; } + public int? HourOfDay { + get { return hourOfDay_; } set { - value_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - valueCase_ = ValueOneofCase.CloudSecret; + hourOfDay_ = value; } } - private object value_; - /// Enum of possible cases for the "value" oneof. - public enum ValueOneofCase { - None = 0, - CloudSecret = 2, - } - private ValueOneofCase valueCase_ = ValueOneofCase.None; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public ValueOneofCase ValueCase { - get { return valueCase_; } - } + /// Field number for the "day_of_week" field. + public const int DayOfWeekFieldNumber = 2; + private global::Google.Type.DayOfWeek dayOfWeek_ = global::Google.Type.DayOfWeek.Unspecified; + /// + /// The day of week, when the window starts. + /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void ClearValue() { - valueCase_ = ValueOneofCase.None; - value_ = null; + public global::Google.Type.DayOfWeek DayOfWeek { + get { return dayOfWeek_; } + set { + dayOfWeek_ = value; + } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as Secret); + return Equals(other as MaintenanceWindow); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(Secret other) { + public bool Equals(MaintenanceWindow other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (CloudSecret != other.CloudSecret) return false; - if (ValueCase != other.ValueCase) return false; + if (HourOfDay != other.HourOfDay) return false; + if (DayOfWeek != other.DayOfWeek) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (valueCase_ == ValueOneofCase.CloudSecret) hash ^= CloudSecret.GetHashCode(); - hash ^= (int) valueCase_; + if (hourOfDay_ != null) hash ^= HourOfDay.GetHashCode(); + if (DayOfWeek != global::Google.Type.DayOfWeek.Unspecified) hash ^= DayOfWeek.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -1582,9 +1723,12 @@ public enum ValueOneofCase { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (valueCase_ == ValueOneofCase.CloudSecret) { - output.WriteRawTag(18); - output.WriteString(CloudSecret); + if (hourOfDay_ != null) { + _single_hourOfDay_codec.WriteTagAndValue(output, HourOfDay); + } + if (DayOfWeek != global::Google.Type.DayOfWeek.Unspecified) { + output.WriteRawTag(16); + output.WriteEnum((int) DayOfWeek); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -1595,9 +1739,12 @@ public enum ValueOneofCase { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE [global::System.Diagnostics.DebuggerNonUserCodeAttribute] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (valueCase_ == ValueOneofCase.CloudSecret) { - output.WriteRawTag(18); - output.WriteString(CloudSecret); + if (hourOfDay_ != null) { + _single_hourOfDay_codec.WriteTagAndValue(ref output, HourOfDay); + } + if (DayOfWeek != global::Google.Type.DayOfWeek.Unspecified) { + output.WriteRawTag(16); + output.WriteEnum((int) DayOfWeek); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -1608,8 +1755,11 @@ public enum ValueOneofCase { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public int CalculateSize() { int size = 0; - if (valueCase_ == ValueOneofCase.CloudSecret) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(CloudSecret); + if (hourOfDay_ != null) { + size += _single_hourOfDay_codec.CalculateSizeWithTag(HourOfDay); + } + if (DayOfWeek != global::Google.Type.DayOfWeek.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DayOfWeek); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -1618,16 +1768,18 @@ public enum ValueOneofCase { } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void MergeFrom(Secret other) { + public void MergeFrom(MaintenanceWindow other) { if (other == null) { return; } - switch (other.ValueCase) { - case ValueOneofCase.CloudSecret: - CloudSecret = other.CloudSecret; - break; + if (other.hourOfDay_ != null) { + if (hourOfDay_ == null || other.HourOfDay != 0) { + HourOfDay = other.HourOfDay; + } + } + if (other.DayOfWeek != global::Google.Type.DayOfWeek.Unspecified) { + DayOfWeek = other.DayOfWeek; } - _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -1642,8 +1794,15 @@ public enum ValueOneofCase { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 18: { - CloudSecret = input.ReadString(); + case 10: { + int? value = _single_hourOfDay_codec.Read(input); + if (hourOfDay_ == null || value != 0) { + HourOfDay = value; + } + break; + } + case 16: { + DayOfWeek = (global::Google.Type.DayOfWeek) input.ReadEnum(); break; } } @@ -1660,8 +1819,15 @@ public enum ValueOneofCase { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 18: { - CloudSecret = input.ReadString(); + case 10: { + int? value = _single_hourOfDay_codec.Read(ref input); + if (hourOfDay_ == null || value != 0) { + HourOfDay = value; + } + break; + } + case 16: { + DayOfWeek = (global::Google.Type.DayOfWeek) input.ReadEnum(); break; } } @@ -1672,17 +1838,18 @@ public enum ValueOneofCase { } /// - /// A metastore resource that imports metadata. + /// Specifies configuration information specific to running Hive metastore + /// software as the metastore service. /// - public sealed partial class MetadataImport : pb::IMessage + public sealed partial class HiveMetastoreConfig : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MetadataImport()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new HiveMetastoreConfig()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { @@ -1695,170 +1862,97 @@ public sealed partial class MetadataImport : pb::IMessage } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public MetadataImport() { + public HiveMetastoreConfig() { OnConstruction(); } partial void OnConstruction(); [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public MetadataImport(MetadataImport other) : this() { - name_ = other.name_; - description_ = other.description_; - createTime_ = other.createTime_ != null ? other.createTime_.Clone() : null; - updateTime_ = other.updateTime_ != null ? other.updateTime_.Clone() : null; - state_ = other.state_; - switch (other.MetadataCase) { - case MetadataOneofCase.DatabaseDump: - DatabaseDump = other.DatabaseDump.Clone(); - break; - } - + public HiveMetastoreConfig(HiveMetastoreConfig other) : this() { + version_ = other.version_; + configOverrides_ = other.configOverrides_.Clone(); + kerberosConfig_ = other.kerberosConfig_ != null ? other.kerberosConfig_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public MetadataImport Clone() { - return new MetadataImport(this); + public HiveMetastoreConfig Clone() { + return new HiveMetastoreConfig(this); } - /// Field number for the "name" field. - public const int NameFieldNumber = 1; - private string name_ = ""; + /// Field number for the "version" field. + public const int VersionFieldNumber = 1; + private string version_ = ""; /// - /// Immutable. The relative resource name of the metadata import, of the form: - /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports/{metadata_import_id}". + /// Immutable. The Hive metastore schema version. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Name { - get { return name_; } + public string Version { + get { return version_; } set { - name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + version_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "description" field. - public const int DescriptionFieldNumber = 2; - private string description_ = ""; + /// Field number for the "config_overrides" field. + public const int ConfigOverridesFieldNumber = 2; + private static readonly pbc::MapField.Codec _map_configOverrides_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 18); + private readonly pbc::MapField configOverrides_ = new pbc::MapField(); /// - /// The description of the metadata import. + /// A mapping of Hive metastore configuration key-value pairs to apply to the + /// Hive metastore (configured in `hive-site.xml`). The mappings + /// override system defaults (some keys cannot be overridden). /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Description { - get { return description_; } - set { - description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + public pbc::MapField ConfigOverrides { + get { return configOverrides_; } } - /// Field number for the "create_time" field. - public const int CreateTimeFieldNumber = 3; - private global::Google.Protobuf.WellKnownTypes.Timestamp createTime_; + /// Field number for the "kerberos_config" field. + public const int KerberosConfigFieldNumber = 3; + private global::Google.Cloud.Metastore.V1Alpha.KerberosConfig kerberosConfig_; /// - /// Output only. The time when the metadata import was created. + /// Information used to configure the Hive metastore service as a service + /// principal in a Kerberos realm. To disable Kerberos, use the `UpdateService` + /// method and specify this field's path + /// (`hive_metastore_config.kerberos_config`) in the request's `update_mask` + /// while omitting this field from the request's `service`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Protobuf.WellKnownTypes.Timestamp CreateTime { - get { return createTime_; } + public global::Google.Cloud.Metastore.V1Alpha.KerberosConfig KerberosConfig { + get { return kerberosConfig_; } set { - createTime_ = value; + kerberosConfig_ = value; } } - /// Field number for the "update_time" field. - public const int UpdateTimeFieldNumber = 4; - private global::Google.Protobuf.WellKnownTypes.Timestamp updateTime_; - /// - /// Output only. The time when the metadata import was last updated. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Protobuf.WellKnownTypes.Timestamp UpdateTime { - get { return updateTime_; } - set { - updateTime_ = value; - } - } - - /// Field number for the "state" field. - public const int StateFieldNumber = 5; - private global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State state_ = global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified; - /// - /// Output only. The current state of the metadata import. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State State { - get { return state_; } - set { - state_ = value; - } - } - - /// Field number for the "database_dump" field. - public const int DatabaseDumpFieldNumber = 6; - /// - /// Immutable. A database dump from a pre-existing metastore's database. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump DatabaseDump { - get { return metadataCase_ == MetadataOneofCase.DatabaseDump ? (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump) metadata_ : null; } - set { - metadata_ = value; - metadataCase_ = value == null ? MetadataOneofCase.None : MetadataOneofCase.DatabaseDump; - } - } - - private object metadata_; - /// Enum of possible cases for the "metadata" oneof. - public enum MetadataOneofCase { - None = 0, - DatabaseDump = 6, - } - private MetadataOneofCase metadataCase_ = MetadataOneofCase.None; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public MetadataOneofCase MetadataCase { - get { return metadataCase_; } - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void ClearMetadata() { - metadataCase_ = MetadataOneofCase.None; - metadata_ = null; - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as MetadataImport); + return Equals(other as HiveMetastoreConfig); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(MetadataImport other) { + public bool Equals(HiveMetastoreConfig other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Name != other.Name) return false; - if (Description != other.Description) return false; - if (!object.Equals(CreateTime, other.CreateTime)) return false; - if (!object.Equals(UpdateTime, other.UpdateTime)) return false; - if (State != other.State) return false; - if (!object.Equals(DatabaseDump, other.DatabaseDump)) return false; - if (MetadataCase != other.MetadataCase) return false; + if (Version != other.Version) return false; + if (!ConfigOverrides.Equals(other.ConfigOverrides)) return false; + if (!object.Equals(KerberosConfig, other.KerberosConfig)) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (Name.Length != 0) hash ^= Name.GetHashCode(); - if (Description.Length != 0) hash ^= Description.GetHashCode(); - if (createTime_ != null) hash ^= CreateTime.GetHashCode(); - if (updateTime_ != null) hash ^= UpdateTime.GetHashCode(); - if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) hash ^= State.GetHashCode(); - if (metadataCase_ == MetadataOneofCase.DatabaseDump) hash ^= DatabaseDump.GetHashCode(); - hash ^= (int) metadataCase_; + if (Version.Length != 0) hash ^= Version.GetHashCode(); + hash ^= ConfigOverrides.GetHashCode(); + if (kerberosConfig_ != null) hash ^= KerberosConfig.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -1875,29 +1969,14 @@ public enum MetadataOneofCase { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Name.Length != 0) { + if (Version.Length != 0) { output.WriteRawTag(10); - output.WriteString(Name); - } - if (Description.Length != 0) { - output.WriteRawTag(18); - output.WriteString(Description); + output.WriteString(Version); } - if (createTime_ != null) { + configOverrides_.WriteTo(output, _map_configOverrides_codec); + if (kerberosConfig_ != null) { output.WriteRawTag(26); - output.WriteMessage(CreateTime); - } - if (updateTime_ != null) { - output.WriteRawTag(34); - output.WriteMessage(UpdateTime); - } - if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) { - output.WriteRawTag(40); - output.WriteEnum((int) State); - } - if (metadataCase_ == MetadataOneofCase.DatabaseDump) { - output.WriteRawTag(50); - output.WriteMessage(DatabaseDump); + output.WriteMessage(KerberosConfig); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -1908,29 +1987,14 @@ public enum MetadataOneofCase { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE [global::System.Diagnostics.DebuggerNonUserCodeAttribute] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Name.Length != 0) { + if (Version.Length != 0) { output.WriteRawTag(10); - output.WriteString(Name); - } - if (Description.Length != 0) { - output.WriteRawTag(18); - output.WriteString(Description); + output.WriteString(Version); } - if (createTime_ != null) { + configOverrides_.WriteTo(ref output, _map_configOverrides_codec); + if (kerberosConfig_ != null) { output.WriteRawTag(26); - output.WriteMessage(CreateTime); - } - if (updateTime_ != null) { - output.WriteRawTag(34); - output.WriteMessage(UpdateTime); - } - if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) { - output.WriteRawTag(40); - output.WriteEnum((int) State); - } - if (metadataCase_ == MetadataOneofCase.DatabaseDump) { - output.WriteRawTag(50); - output.WriteMessage(DatabaseDump); + output.WriteMessage(KerberosConfig); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -1941,23 +2005,12 @@ public enum MetadataOneofCase { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public int CalculateSize() { int size = 0; - if (Name.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); - } - if (Description.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); - } - if (createTime_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(CreateTime); - } - if (updateTime_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateTime); - } - if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) { - size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) State); + if (Version.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Version); } - if (metadataCase_ == MetadataOneofCase.DatabaseDump) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(DatabaseDump); + size += configOverrides_.CalculateSize(_map_configOverrides_codec); + if (kerberosConfig_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(KerberosConfig); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -1966,40 +2019,20 @@ public enum MetadataOneofCase { } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void MergeFrom(MetadataImport other) { + public void MergeFrom(HiveMetastoreConfig other) { if (other == null) { return; } - if (other.Name.Length != 0) { - Name = other.Name; - } - if (other.Description.Length != 0) { - Description = other.Description; - } - if (other.createTime_ != null) { - if (createTime_ == null) { - CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); - } - CreateTime.MergeFrom(other.CreateTime); + if (other.Version.Length != 0) { + Version = other.Version; } - if (other.updateTime_ != null) { - if (updateTime_ == null) { - UpdateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + configOverrides_.Add(other.configOverrides_); + if (other.kerberosConfig_ != null) { + if (kerberosConfig_ == null) { + KerberosConfig = new global::Google.Cloud.Metastore.V1Alpha.KerberosConfig(); } - UpdateTime.MergeFrom(other.UpdateTime); - } - if (other.State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) { - State = other.State; - } - switch (other.MetadataCase) { - case MetadataOneofCase.DatabaseDump: - if (DatabaseDump == null) { - DatabaseDump = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump(); - } - DatabaseDump.MergeFrom(other.DatabaseDump); - break; + KerberosConfig.MergeFrom(other.KerberosConfig); } - _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -2015,38 +2048,18 @@ public enum MetadataOneofCase { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Name = input.ReadString(); + Version = input.ReadString(); break; } case 18: { - Description = input.ReadString(); + configOverrides_.AddEntriesFrom(input, _map_configOverrides_codec); break; } case 26: { - if (createTime_ == null) { - CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); - } - input.ReadMessage(CreateTime); - break; - } - case 34: { - if (updateTime_ == null) { - UpdateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); - } - input.ReadMessage(UpdateTime); - break; - } - case 40: { - State = (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State) input.ReadEnum(); - break; - } - case 50: { - global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump subBuilder = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump(); - if (metadataCase_ == MetadataOneofCase.DatabaseDump) { - subBuilder.MergeFrom(DatabaseDump); + if (kerberosConfig_ == null) { + KerberosConfig = new global::Google.Cloud.Metastore.V1Alpha.KerberosConfig(); } - input.ReadMessage(subBuilder); - DatabaseDump = subBuilder; + input.ReadMessage(KerberosConfig); break; } } @@ -2064,38 +2077,18 @@ public enum MetadataOneofCase { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Name = input.ReadString(); + Version = input.ReadString(); break; } case 18: { - Description = input.ReadString(); + configOverrides_.AddEntriesFrom(ref input, _map_configOverrides_codec); break; } case 26: { - if (createTime_ == null) { - CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); - } - input.ReadMessage(CreateTime); - break; - } - case 34: { - if (updateTime_ == null) { - UpdateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); - } - input.ReadMessage(UpdateTime); - break; - } - case 40: { - State = (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State) input.ReadEnum(); - break; - } - case 50: { - global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump subBuilder = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump(); - if (metadataCase_ == MetadataOneofCase.DatabaseDump) { - subBuilder.MergeFrom(DatabaseDump); + if (kerberosConfig_ == null) { + KerberosConfig = new global::Google.Cloud.Metastore.V1Alpha.KerberosConfig(); } - input.ReadMessage(subBuilder); - DatabaseDump = subBuilder; + input.ReadMessage(KerberosConfig); break; } } @@ -2103,337 +2096,4394 @@ public enum MetadataOneofCase { } #endif - #region Nested types - /// Container for nested types declared in the MetadataImport message type. - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static partial class Types { - /// - /// The current state of the metadata import. - /// - public enum State { - /// + } + + /// + /// Configuration information for a Kerberos principal. + /// + public sealed partial class KerberosConfig : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new KerberosConfig()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public KerberosConfig() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public KerberosConfig(KerberosConfig other) : this() { + keytab_ = other.keytab_ != null ? other.keytab_.Clone() : null; + principal_ = other.principal_; + krb5ConfigGcsUri_ = other.krb5ConfigGcsUri_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public KerberosConfig Clone() { + return new KerberosConfig(this); + } + + /// Field number for the "keytab" field. + public const int KeytabFieldNumber = 1; + private global::Google.Cloud.Metastore.V1Alpha.Secret keytab_; + /// + /// A Kerberos keytab file that can be used to authenticate a service principal + /// with a Kerberos Key Distribution Center (KDC). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.Secret Keytab { + get { return keytab_; } + set { + keytab_ = value; + } + } + + /// Field number for the "principal" field. + public const int PrincipalFieldNumber = 2; + private string principal_ = ""; + /// + /// A Kerberos principal that exists in the both the keytab the KDC + /// to authenticate as. A typical principal is of the form + /// `primary/instance@REALM`, but there is no exact format. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Principal { + get { return principal_; } + set { + principal_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "krb5_config_gcs_uri" field. + public const int Krb5ConfigGcsUriFieldNumber = 3; + private string krb5ConfigGcsUri_ = ""; + /// + /// A Cloud Storage URI that specifies the path to a + /// krb5.conf file. It is of the form gs://{bucket_name}/path/to/krb5.conf, + /// although the file does not need to be named krb5.conf explicitly. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Krb5ConfigGcsUri { + get { return krb5ConfigGcsUri_; } + set { + krb5ConfigGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as KerberosConfig); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(KerberosConfig other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Keytab, other.Keytab)) return false; + if (Principal != other.Principal) return false; + if (Krb5ConfigGcsUri != other.Krb5ConfigGcsUri) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (keytab_ != null) hash ^= Keytab.GetHashCode(); + if (Principal.Length != 0) hash ^= Principal.GetHashCode(); + if (Krb5ConfigGcsUri.Length != 0) hash ^= Krb5ConfigGcsUri.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (keytab_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Keytab); + } + if (Principal.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Principal); + } + if (Krb5ConfigGcsUri.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Krb5ConfigGcsUri); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (keytab_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Keytab); + } + if (Principal.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Principal); + } + if (Krb5ConfigGcsUri.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Krb5ConfigGcsUri); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (keytab_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Keytab); + } + if (Principal.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Principal); + } + if (Krb5ConfigGcsUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Krb5ConfigGcsUri); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(KerberosConfig other) { + if (other == null) { + return; + } + if (other.keytab_ != null) { + if (keytab_ == null) { + Keytab = new global::Google.Cloud.Metastore.V1Alpha.Secret(); + } + Keytab.MergeFrom(other.Keytab); + } + if (other.Principal.Length != 0) { + Principal = other.Principal; + } + if (other.Krb5ConfigGcsUri.Length != 0) { + Krb5ConfigGcsUri = other.Krb5ConfigGcsUri; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (keytab_ == null) { + Keytab = new global::Google.Cloud.Metastore.V1Alpha.Secret(); + } + input.ReadMessage(Keytab); + break; + } + case 18: { + Principal = input.ReadString(); + break; + } + case 26: { + Krb5ConfigGcsUri = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (keytab_ == null) { + Keytab = new global::Google.Cloud.Metastore.V1Alpha.Secret(); + } + input.ReadMessage(Keytab); + break; + } + case 18: { + Principal = input.ReadString(); + break; + } + case 26: { + Krb5ConfigGcsUri = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// A securely stored value. + /// + public sealed partial class Secret : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Secret()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Secret() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Secret(Secret other) : this() { + switch (other.ValueCase) { + case ValueOneofCase.CloudSecret: + CloudSecret = other.CloudSecret; + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Secret Clone() { + return new Secret(this); + } + + /// Field number for the "cloud_secret" field. + public const int CloudSecretFieldNumber = 2; + /// + /// The relative resource name of a Secret Manager secret version, in the + /// following form: + /// + /// `projects/{project_number}/secrets/{secret_id}/versions/{version_id}`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string CloudSecret { + get { return valueCase_ == ValueOneofCase.CloudSecret ? (string) value_ : ""; } + set { + value_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + valueCase_ = ValueOneofCase.CloudSecret; + } + } + + private object value_; + /// Enum of possible cases for the "value" oneof. + public enum ValueOneofCase { + None = 0, + CloudSecret = 2, + } + private ValueOneofCase valueCase_ = ValueOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ValueOneofCase ValueCase { + get { return valueCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void ClearValue() { + valueCase_ = ValueOneofCase.None; + value_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Secret); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Secret other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CloudSecret != other.CloudSecret) return false; + if (ValueCase != other.ValueCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (valueCase_ == ValueOneofCase.CloudSecret) hash ^= CloudSecret.GetHashCode(); + hash ^= (int) valueCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (valueCase_ == ValueOneofCase.CloudSecret) { + output.WriteRawTag(18); + output.WriteString(CloudSecret); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (valueCase_ == ValueOneofCase.CloudSecret) { + output.WriteRawTag(18); + output.WriteString(CloudSecret); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (valueCase_ == ValueOneofCase.CloudSecret) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CloudSecret); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Secret other) { + if (other == null) { + return; + } + switch (other.ValueCase) { + case ValueOneofCase.CloudSecret: + CloudSecret = other.CloudSecret; + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 18: { + CloudSecret = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 18: { + CloudSecret = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// The metadata management activities of the metastore service. + /// + public sealed partial class MetadataManagementActivity : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MetadataManagementActivity()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataManagementActivity() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataManagementActivity(MetadataManagementActivity other) : this() { + metadataExports_ = other.metadataExports_.Clone(); + restores_ = other.restores_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataManagementActivity Clone() { + return new MetadataManagementActivity(this); + } + + /// Field number for the "metadata_exports" field. + public const int MetadataExportsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_metadataExports_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Parser); + private readonly pbc::RepeatedField metadataExports_ = new pbc::RepeatedField(); + /// + /// Output only. The latest metadata exports of the metastore service. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField MetadataExports { + get { return metadataExports_; } + } + + /// Field number for the "restores" field. + public const int RestoresFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_restores_codec + = pb::FieldCodec.ForMessage(18, global::Google.Cloud.Metastore.V1Alpha.Restore.Parser); + private readonly pbc::RepeatedField restores_ = new pbc::RepeatedField(); + /// + /// Output only. The latest restores of the metastore service. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Restores { + get { return restores_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as MetadataManagementActivity); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(MetadataManagementActivity other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!metadataExports_.Equals(other.metadataExports_)) return false; + if(!restores_.Equals(other.restores_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= metadataExports_.GetHashCode(); + hash ^= restores_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + metadataExports_.WriteTo(output, _repeated_metadataExports_codec); + restores_.WriteTo(output, _repeated_restores_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + metadataExports_.WriteTo(ref output, _repeated_metadataExports_codec); + restores_.WriteTo(ref output, _repeated_restores_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += metadataExports_.CalculateSize(_repeated_metadataExports_codec); + size += restores_.CalculateSize(_repeated_restores_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(MetadataManagementActivity other) { + if (other == null) { + return; + } + metadataExports_.Add(other.metadataExports_); + restores_.Add(other.restores_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + metadataExports_.AddEntriesFrom(input, _repeated_metadataExports_codec); + break; + } + case 18: { + restores_.AddEntriesFrom(input, _repeated_restores_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + metadataExports_.AddEntriesFrom(ref input, _repeated_metadataExports_codec); + break; + } + case 18: { + restores_.AddEntriesFrom(ref input, _repeated_restores_codec); + break; + } + } + } + } + #endif + + } + + /// + /// A metastore resource that imports metadata. + /// + public sealed partial class MetadataImport : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MetadataImport()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataImport() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataImport(MetadataImport other) : this() { + name_ = other.name_; + description_ = other.description_; + createTime_ = other.createTime_ != null ? other.createTime_.Clone() : null; + updateTime_ = other.updateTime_ != null ? other.updateTime_.Clone() : null; + state_ = other.state_; + switch (other.MetadataCase) { + case MetadataOneofCase.DatabaseDump: + DatabaseDump = other.DatabaseDump.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataImport Clone() { + return new MetadataImport(this); + } + + /// Field number for the "database_dump" field. + public const int DatabaseDumpFieldNumber = 6; + /// + /// Immutable. A database dump from a pre-existing metastore's database. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump DatabaseDump { + get { return metadataCase_ == MetadataOneofCase.DatabaseDump ? (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump) metadata_ : null; } + set { + metadata_ = value; + metadataCase_ = value == null ? MetadataOneofCase.None : MetadataOneofCase.DatabaseDump; + } + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Immutable. The relative resource name of the metadata import, of the form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports/{metadata_import_id}`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 2; + private string description_ = ""; + /// + /// The description of the metadata import. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "create_time" field. + public const int CreateTimeFieldNumber = 3; + private global::Google.Protobuf.WellKnownTypes.Timestamp createTime_; + /// + /// Output only. The time when the metadata import was created. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp CreateTime { + get { return createTime_; } + set { + createTime_ = value; + } + } + + /// Field number for the "update_time" field. + public const int UpdateTimeFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp updateTime_; + /// + /// Output only. The time when the metadata import was last updated. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp UpdateTime { + get { return updateTime_; } + set { + updateTime_ = value; + } + } + + /// Field number for the "state" field. + public const int StateFieldNumber = 5; + private global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State state_ = global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified; + /// + /// Output only. The current state of the metadata import. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State State { + get { return state_; } + set { + state_ = value; + } + } + + private object metadata_; + /// Enum of possible cases for the "metadata" oneof. + public enum MetadataOneofCase { + None = 0, + DatabaseDump = 6, + } + private MetadataOneofCase metadataCase_ = MetadataOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataOneofCase MetadataCase { + get { return metadataCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void ClearMetadata() { + metadataCase_ = MetadataOneofCase.None; + metadata_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as MetadataImport); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(MetadataImport other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(DatabaseDump, other.DatabaseDump)) return false; + if (Name != other.Name) return false; + if (Description != other.Description) return false; + if (!object.Equals(CreateTime, other.CreateTime)) return false; + if (!object.Equals(UpdateTime, other.UpdateTime)) return false; + if (State != other.State) return false; + if (MetadataCase != other.MetadataCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (metadataCase_ == MetadataOneofCase.DatabaseDump) hash ^= DatabaseDump.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (createTime_ != null) hash ^= CreateTime.GetHashCode(); + if (updateTime_ != null) hash ^= UpdateTime.GetHashCode(); + if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) hash ^= State.GetHashCode(); + hash ^= (int) metadataCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Description.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Description); + } + if (createTime_ != null) { + output.WriteRawTag(26); + output.WriteMessage(CreateTime); + } + if (updateTime_ != null) { + output.WriteRawTag(34); + output.WriteMessage(UpdateTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) { + output.WriteRawTag(40); + output.WriteEnum((int) State); + } + if (metadataCase_ == MetadataOneofCase.DatabaseDump) { + output.WriteRawTag(50); + output.WriteMessage(DatabaseDump); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Description.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Description); + } + if (createTime_ != null) { + output.WriteRawTag(26); + output.WriteMessage(CreateTime); + } + if (updateTime_ != null) { + output.WriteRawTag(34); + output.WriteMessage(UpdateTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) { + output.WriteRawTag(40); + output.WriteEnum((int) State); + } + if (metadataCase_ == MetadataOneofCase.DatabaseDump) { + output.WriteRawTag(50); + output.WriteMessage(DatabaseDump); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (metadataCase_ == MetadataOneofCase.DatabaseDump) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DatabaseDump); + } + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (createTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(CreateTime); + } + if (updateTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) State); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(MetadataImport other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.Description.Length != 0) { + Description = other.Description; + } + if (other.createTime_ != null) { + if (createTime_ == null) { + CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + CreateTime.MergeFrom(other.CreateTime); + } + if (other.updateTime_ != null) { + if (updateTime_ == null) { + UpdateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + UpdateTime.MergeFrom(other.UpdateTime); + } + if (other.State != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State.Unspecified) { + State = other.State; + } + switch (other.MetadataCase) { + case MetadataOneofCase.DatabaseDump: + if (DatabaseDump == null) { + DatabaseDump = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump(); + } + DatabaseDump.MergeFrom(other.DatabaseDump); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Description = input.ReadString(); + break; + } + case 26: { + if (createTime_ == null) { + CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(CreateTime); + break; + } + case 34: { + if (updateTime_ == null) { + UpdateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(UpdateTime); + break; + } + case 40: { + State = (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State) input.ReadEnum(); + break; + } + case 50: { + global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump subBuilder = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump(); + if (metadataCase_ == MetadataOneofCase.DatabaseDump) { + subBuilder.MergeFrom(DatabaseDump); + } + input.ReadMessage(subBuilder); + DatabaseDump = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Description = input.ReadString(); + break; + } + case 26: { + if (createTime_ == null) { + CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(CreateTime); + break; + } + case 34: { + if (updateTime_ == null) { + UpdateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(UpdateTime); + break; + } + case 40: { + State = (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.State) input.ReadEnum(); + break; + } + case 50: { + global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump subBuilder = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump(); + if (metadataCase_ == MetadataOneofCase.DatabaseDump) { + subBuilder.MergeFrom(DatabaseDump); + } + input.ReadMessage(subBuilder); + DatabaseDump = subBuilder; + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the MetadataImport message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// The current state of the metadata import. + /// + public enum State { + /// /// The state of the metadata import is unknown. /// [pbr::OriginalName("STATE_UNSPECIFIED")] Unspecified = 0, /// - /// The metadata import is running. + /// The metadata import is running. + /// + [pbr::OriginalName("RUNNING")] Running = 1, + /// + /// The metadata import completed successfully. + /// + [pbr::OriginalName("SUCCEEDED")] Succeeded = 2, + /// + /// The metadata import is being updated. + /// + [pbr::OriginalName("UPDATING")] Updating = 3, + /// + /// The metadata import failed, and attempted metadata changes were rolled + /// back. + /// + [pbr::OriginalName("FAILED")] Failed = 4, + } + + /// + /// A specification of the location of and metadata about a database dump from + /// a relational database management system. + /// + public sealed partial class DatabaseDump : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DatabaseDump()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DatabaseDump() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DatabaseDump(DatabaseDump other) : this() { + databaseType_ = other.databaseType_; + gcsUri_ = other.gcsUri_; + sourceDatabase_ = other.sourceDatabase_; + type_ = other.type_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DatabaseDump Clone() { + return new DatabaseDump(this); + } + + /// Field number for the "database_type" field. + public const int DatabaseTypeFieldNumber = 1; + private global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType databaseType_ = global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified; + /// + /// The type of the database. + /// + [global::System.ObsoleteAttribute] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType DatabaseType { + get { return databaseType_; } + set { + databaseType_ = value; + } + } + + /// Field number for the "gcs_uri" field. + public const int GcsUriFieldNumber = 2; + private string gcsUri_ = ""; + /// + /// A Cloud Storage object or folder URI that specifies the source from which + /// to import metadata. It must begin with `gs://`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string GcsUri { + get { return gcsUri_; } + set { + gcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "source_database" field. + public const int SourceDatabaseFieldNumber = 3; + private string sourceDatabase_ = ""; + /// + /// The name of the source database. + /// + [global::System.ObsoleteAttribute] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string SourceDatabase { + get { return sourceDatabase_; } + set { + sourceDatabase_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 4; + private global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type type_ = global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified; + /// + /// Optional. The type of the database dump. If unspecified, defaults to `MYSQL`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type Type { + get { return type_; } + set { + type_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as DatabaseDump); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(DatabaseDump other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (DatabaseType != other.DatabaseType) return false; + if (GcsUri != other.GcsUri) return false; + if (SourceDatabase != other.SourceDatabase) return false; + if (Type != other.Type) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) hash ^= DatabaseType.GetHashCode(); + if (GcsUri.Length != 0) hash ^= GcsUri.GetHashCode(); + if (SourceDatabase.Length != 0) hash ^= SourceDatabase.GetHashCode(); + if (Type != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) hash ^= Type.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) DatabaseType); + } + if (GcsUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(GcsUri); + } + if (SourceDatabase.Length != 0) { + output.WriteRawTag(26); + output.WriteString(SourceDatabase); + } + if (Type != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) Type); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) DatabaseType); + } + if (GcsUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(GcsUri); + } + if (SourceDatabase.Length != 0) { + output.WriteRawTag(26); + output.WriteString(SourceDatabase); + } + if (Type != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) Type); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DatabaseType); + } + if (GcsUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(GcsUri); + } + if (SourceDatabase.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SourceDatabase); + } + if (Type != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(DatabaseDump other) { + if (other == null) { + return; + } + if (other.DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) { + DatabaseType = other.DatabaseType; + } + if (other.GcsUri.Length != 0) { + GcsUri = other.GcsUri; + } + if (other.SourceDatabase.Length != 0) { + SourceDatabase = other.SourceDatabase; + } + if (other.Type != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) { + Type = other.Type; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + DatabaseType = (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType) input.ReadEnum(); + break; + } + case 18: { + GcsUri = input.ReadString(); + break; + } + case 26: { + SourceDatabase = input.ReadString(); + break; + } + case 32: { + Type = (global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type) input.ReadEnum(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + DatabaseType = (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType) input.ReadEnum(); + break; + } + case 18: { + GcsUri = input.ReadString(); + break; + } + case 26: { + SourceDatabase = input.ReadString(); + break; + } + case 32: { + Type = (global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type) input.ReadEnum(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the DatabaseDump message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// The type of the database. + /// + public enum DatabaseType { + /// + /// The type of the source database is unknown. + /// + [pbr::OriginalName("DATABASE_TYPE_UNSPECIFIED")] Unspecified = 0, + /// + /// The type of the source database is MySQL. + /// + [pbr::OriginalName("MYSQL")] Mysql = 1, + } + + } + #endregion + + } + + } + #endregion + + } + + /// + /// The details of a metadata export operation. + /// + public sealed partial class MetadataExport : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MetadataExport()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataExport() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataExport(MetadataExport other) : this() { + startTime_ = other.startTime_ != null ? other.startTime_.Clone() : null; + endTime_ = other.endTime_ != null ? other.endTime_.Clone() : null; + state_ = other.state_; + databaseDumpType_ = other.databaseDumpType_; + switch (other.DestinationCase) { + case DestinationOneofCase.DestinationGcsUri: + DestinationGcsUri = other.DestinationGcsUri; + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public MetadataExport Clone() { + return new MetadataExport(this); + } + + /// Field number for the "destination_gcs_uri" field. + public const int DestinationGcsUriFieldNumber = 4; + /// + /// Output only. A Cloud Storage URI of a folder that metadata are exported to, in the + /// form of `gs://<bucket_name>/<path_inside_bucket>/<export_folder>`, where + /// `<export_folder>` is automatically generated. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string DestinationGcsUri { + get { return destinationCase_ == DestinationOneofCase.DestinationGcsUri ? (string) destination_ : ""; } + set { + destination_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + destinationCase_ = DestinationOneofCase.DestinationGcsUri; + } + } + + /// Field number for the "start_time" field. + public const int StartTimeFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.Timestamp startTime_; + /// + /// Output only. The time when the export started. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp StartTime { + get { return startTime_; } + set { + startTime_ = value; + } + } + + /// Field number for the "end_time" field. + public const int EndTimeFieldNumber = 2; + private global::Google.Protobuf.WellKnownTypes.Timestamp endTime_; + /// + /// Output only. The time when the export ended. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp EndTime { + get { return endTime_; } + set { + endTime_ = value; + } + } + + /// Field number for the "state" field. + public const int StateFieldNumber = 3; + private global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State state_ = global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State.Unspecified; + /// + /// Output only. The current state of the export. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State State { + get { return state_; } + set { + state_ = value; + } + } + + /// Field number for the "database_dump_type" field. + public const int DatabaseDumpTypeFieldNumber = 5; + private global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type databaseDumpType_ = global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified; + /// + /// Output only. The type of the database dump. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type DatabaseDumpType { + get { return databaseDumpType_; } + set { + databaseDumpType_ = value; + } + } + + private object destination_; + /// Enum of possible cases for the "destination" oneof. + public enum DestinationOneofCase { + None = 0, + DestinationGcsUri = 4, + } + private DestinationOneofCase destinationCase_ = DestinationOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DestinationOneofCase DestinationCase { + get { return destinationCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void ClearDestination() { + destinationCase_ = DestinationOneofCase.None; + destination_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as MetadataExport); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(MetadataExport other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (DestinationGcsUri != other.DestinationGcsUri) return false; + if (!object.Equals(StartTime, other.StartTime)) return false; + if (!object.Equals(EndTime, other.EndTime)) return false; + if (State != other.State) return false; + if (DatabaseDumpType != other.DatabaseDumpType) return false; + if (DestinationCase != other.DestinationCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (destinationCase_ == DestinationOneofCase.DestinationGcsUri) hash ^= DestinationGcsUri.GetHashCode(); + if (startTime_ != null) hash ^= StartTime.GetHashCode(); + if (endTime_ != null) hash ^= EndTime.GetHashCode(); + if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State.Unspecified) hash ^= State.GetHashCode(); + if (DatabaseDumpType != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) hash ^= DatabaseDumpType.GetHashCode(); + hash ^= (int) destinationCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (startTime_ != null) { + output.WriteRawTag(10); + output.WriteMessage(StartTime); + } + if (endTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) State); + } + if (destinationCase_ == DestinationOneofCase.DestinationGcsUri) { + output.WriteRawTag(34); + output.WriteString(DestinationGcsUri); + } + if (DatabaseDumpType != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) { + output.WriteRawTag(40); + output.WriteEnum((int) DatabaseDumpType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (startTime_ != null) { + output.WriteRawTag(10); + output.WriteMessage(StartTime); + } + if (endTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) State); + } + if (destinationCase_ == DestinationOneofCase.DestinationGcsUri) { + output.WriteRawTag(34); + output.WriteString(DestinationGcsUri); + } + if (DatabaseDumpType != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) { + output.WriteRawTag(40); + output.WriteEnum((int) DatabaseDumpType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (destinationCase_ == DestinationOneofCase.DestinationGcsUri) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DestinationGcsUri); + } + if (startTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(StartTime); + } + if (endTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) State); + } + if (DatabaseDumpType != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DatabaseDumpType); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(MetadataExport other) { + if (other == null) { + return; + } + if (other.startTime_ != null) { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + StartTime.MergeFrom(other.StartTime); + } + if (other.endTime_ != null) { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + EndTime.MergeFrom(other.EndTime); + } + if (other.State != global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State.Unspecified) { + State = other.State; + } + if (other.DatabaseDumpType != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) { + DatabaseDumpType = other.DatabaseDumpType; + } + switch (other.DestinationCase) { + case DestinationOneofCase.DestinationGcsUri: + DestinationGcsUri = other.DestinationGcsUri; + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(StartTime); + break; + } + case 18: { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(EndTime); + break; + } + case 24: { + State = (global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State) input.ReadEnum(); + break; + } + case 34: { + DestinationGcsUri = input.ReadString(); + break; + } + case 40: { + DatabaseDumpType = (global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type) input.ReadEnum(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(StartTime); + break; + } + case 18: { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(EndTime); + break; + } + case 24: { + State = (global::Google.Cloud.Metastore.V1Alpha.MetadataExport.Types.State) input.ReadEnum(); + break; + } + case 34: { + DestinationGcsUri = input.ReadString(); + break; + } + case 40: { + DatabaseDumpType = (global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type) input.ReadEnum(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the MetadataExport message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// The current state of the metadata export. + /// + public enum State { + /// + /// The state of the metadata export is unknown. + /// + [pbr::OriginalName("STATE_UNSPECIFIED")] Unspecified = 0, + /// + /// The metadata export is running. + /// + [pbr::OriginalName("RUNNING")] Running = 1, + /// + /// The metadata export completed successfully. + /// + [pbr::OriginalName("SUCCEEDED")] Succeeded = 2, + /// + /// The metadata export failed. + /// + [pbr::OriginalName("FAILED")] Failed = 3, + /// + /// The metadata export is cancelled. + /// + [pbr::OriginalName("CANCELLED")] Cancelled = 4, + } + + } + #endregion + + } + + /// + /// The details of a backup resource. + /// + public sealed partial class Backup : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Backup()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[10]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Backup() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Backup(Backup other) : this() { + name_ = other.name_; + createTime_ = other.createTime_ != null ? other.createTime_.Clone() : null; + endTime_ = other.endTime_ != null ? other.endTime_.Clone() : null; + state_ = other.state_; + serviceRevision_ = other.serviceRevision_ != null ? other.serviceRevision_.Clone() : null; + description_ = other.description_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Backup Clone() { + return new Backup(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Immutable. The relative resource name of the backup, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}` + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "create_time" field. + public const int CreateTimeFieldNumber = 2; + private global::Google.Protobuf.WellKnownTypes.Timestamp createTime_; + /// + /// Output only. The time when the backup was started. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp CreateTime { + get { return createTime_; } + set { + createTime_ = value; + } + } + + /// Field number for the "end_time" field. + public const int EndTimeFieldNumber = 3; + private global::Google.Protobuf.WellKnownTypes.Timestamp endTime_; + /// + /// Output only. The time when the backup finished creating. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp EndTime { + get { return endTime_; } + set { + endTime_ = value; + } + } + + /// Field number for the "state" field. + public const int StateFieldNumber = 4; + private global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State state_ = global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State.Unspecified; + /// + /// Output only. The current state of the backup. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State State { + get { return state_; } + set { + state_ = value; + } + } + + /// Field number for the "service_revision" field. + public const int ServiceRevisionFieldNumber = 5; + private global::Google.Cloud.Metastore.V1Alpha.Service serviceRevision_; + /// + /// Output only. The revision of the service at the time of backup. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.Service ServiceRevision { + get { return serviceRevision_; } + set { + serviceRevision_ = value; + } + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 6; + private string description_ = ""; + /// + /// The description of the backup. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Backup); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Backup other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (!object.Equals(CreateTime, other.CreateTime)) return false; + if (!object.Equals(EndTime, other.EndTime)) return false; + if (State != other.State) return false; + if (!object.Equals(ServiceRevision, other.ServiceRevision)) return false; + if (Description != other.Description) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (createTime_ != null) hash ^= CreateTime.GetHashCode(); + if (endTime_ != null) hash ^= EndTime.GetHashCode(); + if (State != global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State.Unspecified) hash ^= State.GetHashCode(); + if (serviceRevision_ != null) hash ^= ServiceRevision.GetHashCode(); + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (createTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(CreateTime); + } + if (endTime_ != null) { + output.WriteRawTag(26); + output.WriteMessage(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) State); + } + if (serviceRevision_ != null) { + output.WriteRawTag(42); + output.WriteMessage(ServiceRevision); + } + if (Description.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Description); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (createTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(CreateTime); + } + if (endTime_ != null) { + output.WriteRawTag(26); + output.WriteMessage(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) State); + } + if (serviceRevision_ != null) { + output.WriteRawTag(42); + output.WriteMessage(ServiceRevision); + } + if (Description.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Description); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (createTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(CreateTime); + } + if (endTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) State); + } + if (serviceRevision_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ServiceRevision); + } + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Backup other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.createTime_ != null) { + if (createTime_ == null) { + CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + CreateTime.MergeFrom(other.CreateTime); + } + if (other.endTime_ != null) { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + EndTime.MergeFrom(other.EndTime); + } + if (other.State != global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State.Unspecified) { + State = other.State; + } + if (other.serviceRevision_ != null) { + if (serviceRevision_ == null) { + ServiceRevision = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + ServiceRevision.MergeFrom(other.ServiceRevision); + } + if (other.Description.Length != 0) { + Description = other.Description; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + if (createTime_ == null) { + CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(CreateTime); + break; + } + case 26: { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(EndTime); + break; + } + case 32: { + State = (global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State) input.ReadEnum(); + break; + } + case 42: { + if (serviceRevision_ == null) { + ServiceRevision = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + input.ReadMessage(ServiceRevision); + break; + } + case 50: { + Description = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + if (createTime_ == null) { + CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(CreateTime); + break; + } + case 26: { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(EndTime); + break; + } + case 32: { + State = (global::Google.Cloud.Metastore.V1Alpha.Backup.Types.State) input.ReadEnum(); + break; + } + case 42: { + if (serviceRevision_ == null) { + ServiceRevision = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + input.ReadMessage(ServiceRevision); + break; + } + case 50: { + Description = input.ReadString(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the Backup message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// The current state of the backup. + /// + public enum State { + /// + /// The state of the backup is unknown. + /// + [pbr::OriginalName("STATE_UNSPECIFIED")] Unspecified = 0, + /// + /// The backup is being created. + /// + [pbr::OriginalName("CREATING")] Creating = 1, + /// + /// The backup is being deleted. + /// + [pbr::OriginalName("DELETING")] Deleting = 2, + /// + /// The backup is active and ready to use. + /// + [pbr::OriginalName("ACTIVE")] Active = 3, + /// + /// The backup failed. + /// + [pbr::OriginalName("FAILED")] Failed = 4, + } + + } + #endregion + + } + + /// + /// The details of a metadata restore operation. + /// + public sealed partial class Restore : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Restore()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Restore() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Restore(Restore other) : this() { + startTime_ = other.startTime_ != null ? other.startTime_.Clone() : null; + endTime_ = other.endTime_ != null ? other.endTime_.Clone() : null; + state_ = other.state_; + backup_ = other.backup_; + type_ = other.type_; + details_ = other.details_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Restore Clone() { + return new Restore(this); + } + + /// Field number for the "start_time" field. + public const int StartTimeFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.Timestamp startTime_; + /// + /// Output only. The time when the restore started. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp StartTime { + get { return startTime_; } + set { + startTime_ = value; + } + } + + /// Field number for the "end_time" field. + public const int EndTimeFieldNumber = 2; + private global::Google.Protobuf.WellKnownTypes.Timestamp endTime_; + /// + /// Output only. The time when the restore ended. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp EndTime { + get { return endTime_; } + set { + endTime_ = value; + } + } + + /// Field number for the "state" field. + public const int StateFieldNumber = 3; + private global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State state_ = global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State.Unspecified; + /// + /// Output only. The current state of the restore. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State State { + get { return state_; } + set { + state_ = value; + } + } + + /// Field number for the "backup" field. + public const int BackupFieldNumber = 4; + private string backup_ = ""; + /// + /// Output only. The relative resource name of the metastore service backup to restore + /// from, in the following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}` + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Backup { + get { return backup_; } + set { + backup_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 5; + private global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType type_ = global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType.Unspecified; + /// + /// Output only. The type of restore. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType Type { + get { return type_; } + set { + type_ = value; + } + } + + /// Field number for the "details" field. + public const int DetailsFieldNumber = 6; + private string details_ = ""; + /// + /// Output only. The restore details containing the revision of the service to be restored + /// to, in format of JSON. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Details { + get { return details_; } + set { + details_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Restore); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Restore other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(StartTime, other.StartTime)) return false; + if (!object.Equals(EndTime, other.EndTime)) return false; + if (State != other.State) return false; + if (Backup != other.Backup) return false; + if (Type != other.Type) return false; + if (Details != other.Details) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (startTime_ != null) hash ^= StartTime.GetHashCode(); + if (endTime_ != null) hash ^= EndTime.GetHashCode(); + if (State != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State.Unspecified) hash ^= State.GetHashCode(); + if (Backup.Length != 0) hash ^= Backup.GetHashCode(); + if (Type != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType.Unspecified) hash ^= Type.GetHashCode(); + if (Details.Length != 0) hash ^= Details.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (startTime_ != null) { + output.WriteRawTag(10); + output.WriteMessage(StartTime); + } + if (endTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) State); + } + if (Backup.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Backup); + } + if (Type != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType.Unspecified) { + output.WriteRawTag(40); + output.WriteEnum((int) Type); + } + if (Details.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Details); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (startTime_ != null) { + output.WriteRawTag(10); + output.WriteMessage(StartTime); + } + if (endTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) State); + } + if (Backup.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Backup); + } + if (Type != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType.Unspecified) { + output.WriteRawTag(40); + output.WriteEnum((int) Type); + } + if (Details.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Details); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (startTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(StartTime); + } + if (endTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(EndTime); + } + if (State != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) State); + } + if (Backup.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Backup); + } + if (Type != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + } + if (Details.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Details); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Restore other) { + if (other == null) { + return; + } + if (other.startTime_ != null) { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + StartTime.MergeFrom(other.StartTime); + } + if (other.endTime_ != null) { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + EndTime.MergeFrom(other.EndTime); + } + if (other.State != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State.Unspecified) { + State = other.State; + } + if (other.Backup.Length != 0) { + Backup = other.Backup; + } + if (other.Type != global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType.Unspecified) { + Type = other.Type; + } + if (other.Details.Length != 0) { + Details = other.Details; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(StartTime); + break; + } + case 18: { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(EndTime); + break; + } + case 24: { + State = (global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State) input.ReadEnum(); + break; + } + case 34: { + Backup = input.ReadString(); + break; + } + case 40: { + Type = (global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType) input.ReadEnum(); + break; + } + case 50: { + Details = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(StartTime); + break; + } + case 18: { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(EndTime); + break; + } + case 24: { + State = (global::Google.Cloud.Metastore.V1Alpha.Restore.Types.State) input.ReadEnum(); + break; + } + case 34: { + Backup = input.ReadString(); + break; + } + case 40: { + Type = (global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType) input.ReadEnum(); + break; + } + case 50: { + Details = input.ReadString(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the Restore message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// The current state of the restore. + /// + public enum State { + /// + /// The state of the metadata restore is unknown. + /// + [pbr::OriginalName("STATE_UNSPECIFIED")] Unspecified = 0, + /// + /// The metadata restore is running. /// [pbr::OriginalName("RUNNING")] Running = 1, /// - /// The metadata import completed successfully. + /// The metadata restore completed successfully. /// [pbr::OriginalName("SUCCEEDED")] Succeeded = 2, /// - /// The metadata import is being updated. + /// The metadata restore failed. /// - [pbr::OriginalName("UPDATING")] Updating = 3, + [pbr::OriginalName("FAILED")] Failed = 3, /// - /// The metadata import failed, and attempted metadata changes were rolled - /// back. + /// The metadata restore is cancelled. /// - [pbr::OriginalName("FAILED")] Failed = 4, + [pbr::OriginalName("CANCELLED")] Cancelled = 4, + } + + /// + /// The type of restore. + /// + public enum RestoreType { + /// + /// The restore type is unknown. + /// + [pbr::OriginalName("RESTORE_TYPE_UNSPECIFIED")] Unspecified = 0, + /// + /// The service's metadata and configuration are restored. + /// + [pbr::OriginalName("FULL")] Full = 1, + /// + /// Only the service's metadata is restored. + /// + [pbr::OriginalName("METADATA_ONLY")] MetadataOnly = 2, + } + + } + #endregion + + } + + /// + /// Request message for [DataprocMetastore.ListServices][google.cloud.metastore.v1alpha.DataprocMetastore.ListServices]. + /// + public sealed partial class ListServicesRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListServicesRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListServicesRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListServicesRequest(ListServicesRequest other) : this() { + parent_ = other.parent_; + pageSize_ = other.pageSize_; + pageToken_ = other.pageToken_; + filter_ = other.filter_; + orderBy_ = other.orderBy_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListServicesRequest Clone() { + return new ListServicesRequest(this); + } + + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; + /// + /// Required. The relative resource name of the location of metastore services to + /// list, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 2; + private int pageSize_; + /// + /// Optional. The maximum number of services to return. The response may contain less + /// than the maximum number. If unspecified, no more than 500 services are + /// returned. The maximum value is 1000; values above 1000 are changed to 1000. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int PageSize { + get { return pageSize_; } + set { + pageSize_ = value; + } + } + + /// Field number for the "page_token" field. + public const int PageTokenFieldNumber = 3; + private string pageToken_ = ""; + /// + /// Optional. A page token, received from a previous [DataprocMetastore.ListServices][google.cloud.metastore.v1alpha.DataprocMetastore.ListServices] + /// call. Provide this token to retrieve the subsequent page. + /// + /// To retrieve the first page, supply an empty page token. + /// + /// When paginating, other parameters provided to + /// [DataprocMetastore.ListServices][google.cloud.metastore.v1alpha.DataprocMetastore.ListServices] must match the call that provided the + /// page token. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string PageToken { + get { return pageToken_; } + set { + pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "filter" field. + public const int FilterFieldNumber = 4; + private string filter_ = ""; + /// + /// Optional. The filter to apply to list results. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Filter { + get { return filter_; } + set { + filter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "order_by" field. + public const int OrderByFieldNumber = 5; + private string orderBy_ = ""; + /// + /// Optional. Specify the ordering of results as described in [Sorting + /// Order](https://cloud.google.com/apis/design/design_patterns#sorting_order). + /// If not specified, the results will be sorted in the default order. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string OrderBy { + get { return orderBy_; } + set { + orderBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ListServicesRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ListServicesRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Parent != other.Parent) return false; + if (PageSize != other.PageSize) return false; + if (PageToken != other.PageToken) return false; + if (Filter != other.Filter) return false; + if (OrderBy != other.OrderBy) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); + if (Filter.Length != 0) hash ^= Filter.GetHashCode(); + if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (PageSize != 0) { + output.WriteRawTag(16); + output.WriteInt32(PageSize); + } + if (PageToken.Length != 0) { + output.WriteRawTag(26); + output.WriteString(PageToken); + } + if (Filter.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Filter); + } + if (OrderBy.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OrderBy); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (PageSize != 0) { + output.WriteRawTag(16); + output.WriteInt32(PageSize); + } + if (PageToken.Length != 0) { + output.WriteRawTag(26); + output.WriteString(PageToken); + } + if (Filter.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Filter); + } + if (OrderBy.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OrderBy); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Parent.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); + } + if (PageSize != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); + } + if (PageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(PageToken); + } + if (Filter.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Filter); + } + if (OrderBy.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OrderBy); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ListServicesRequest other) { + if (other == null) { + return; + } + if (other.Parent.Length != 0) { + Parent = other.Parent; + } + if (other.PageSize != 0) { + PageSize = other.PageSize; + } + if (other.PageToken.Length != 0) { + PageToken = other.PageToken; + } + if (other.Filter.Length != 0) { + Filter = other.Filter; + } + if (other.OrderBy.Length != 0) { + OrderBy = other.OrderBy; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Parent = input.ReadString(); + break; + } + case 16: { + PageSize = input.ReadInt32(); + break; + } + case 26: { + PageToken = input.ReadString(); + break; + } + case 34: { + Filter = input.ReadString(); + break; + } + case 42: { + OrderBy = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Parent = input.ReadString(); + break; + } + case 16: { + PageSize = input.ReadInt32(); + break; + } + case 26: { + PageToken = input.ReadString(); + break; + } + case 34: { + Filter = input.ReadString(); + break; + } + case 42: { + OrderBy = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Response message for [DataprocMetastore.ListServices][google.cloud.metastore.v1alpha.DataprocMetastore.ListServices]. + /// + public sealed partial class ListServicesResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListServicesResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[13]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListServicesResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListServicesResponse(ListServicesResponse other) : this() { + services_ = other.services_.Clone(); + nextPageToken_ = other.nextPageToken_; + unreachable_ = other.unreachable_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListServicesResponse Clone() { + return new ListServicesResponse(this); + } + + /// Field number for the "services" field. + public const int ServicesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_services_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.Metastore.V1Alpha.Service.Parser); + private readonly pbc::RepeatedField services_ = new pbc::RepeatedField(); + /// + /// The services in the specified location. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Services { + get { return services_; } + } + + /// Field number for the "next_page_token" field. + public const int NextPageTokenFieldNumber = 2; + private string nextPageToken_ = ""; + /// + /// A token that can be sent as `page_token` to retrieve the next page. If this + /// field is omitted, there are no subsequent pages. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string NextPageToken { + get { return nextPageToken_; } + set { + nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "unreachable" field. + public const int UnreachableFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_unreachable_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); + /// + /// Locations that could not be reached. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Unreachable { + get { return unreachable_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ListServicesResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ListServicesResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!services_.Equals(other.services_)) return false; + if (NextPageToken != other.NextPageToken) return false; + if(!unreachable_.Equals(other.unreachable_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= services_.GetHashCode(); + if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); + hash ^= unreachable_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + services_.WriteTo(output, _repeated_services_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); + } + unreachable_.WriteTo(output, _repeated_unreachable_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + services_.WriteTo(ref output, _repeated_services_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); + } + unreachable_.WriteTo(ref output, _repeated_unreachable_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += services_.CalculateSize(_repeated_services_codec); + if (NextPageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); + } + size += unreachable_.CalculateSize(_repeated_unreachable_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ListServicesResponse other) { + if (other == null) { + return; + } + services_.Add(other.services_); + if (other.NextPageToken.Length != 0) { + NextPageToken = other.NextPageToken; + } + unreachable_.Add(other.unreachable_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + services_.AddEntriesFrom(input, _repeated_services_codec); + break; + } + case 18: { + NextPageToken = input.ReadString(); + break; + } + case 26: { + unreachable_.AddEntriesFrom(input, _repeated_unreachable_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + services_.AddEntriesFrom(ref input, _repeated_services_codec); + break; + } + case 18: { + NextPageToken = input.ReadString(); + break; + } + case 26: { + unreachable_.AddEntriesFrom(ref input, _repeated_unreachable_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Request message for [DataprocMetastore.GetService][google.cloud.metastore.v1alpha.DataprocMetastore.GetService]. + /// + public sealed partial class GetServiceRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetServiceRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[14]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServiceRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServiceRequest(GetServiceRequest other) : this() { + name_ = other.name_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServiceRequest Clone() { + return new GetServiceRequest(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Required. The relative resource name of the metastore service to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as GetServiceRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(GetServiceRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(GetServiceRequest other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Request message for [DataprocMetastore.CreateService][google.cloud.metastore.v1alpha.DataprocMetastore.CreateService]. + /// + public sealed partial class CreateServiceRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateServiceRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[15]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public CreateServiceRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public CreateServiceRequest(CreateServiceRequest other) : this() { + parent_ = other.parent_; + serviceId_ = other.serviceId_; + service_ = other.service_ != null ? other.service_.Clone() : null; + requestId_ = other.requestId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public CreateServiceRequest Clone() { + return new CreateServiceRequest(this); + } + + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; + /// + /// Required. The relative resource name of the location in which to create a metastore + /// service, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "service_id" field. + public const int ServiceIdFieldNumber = 2; + private string serviceId_ = ""; + /// + /// Required. The ID of the metastore service, which is used as the final + /// component of the metastore service's name. + /// + /// This value must be between 2 and 63 characters long inclusive, begin with a + /// letter, end with a letter or number, and consist of alpha-numeric + /// ASCII characters or hyphens. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string ServiceId { + get { return serviceId_; } + set { + serviceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "service" field. + public const int ServiceFieldNumber = 3; + private global::Google.Cloud.Metastore.V1Alpha.Service service_; + /// + /// Required. The Metastore service to create. The `name` field is + /// ignored. The ID of the created metastore service must be provided in + /// the request's `service_id` field. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.Service Service { + get { return service_; } + set { + service_ = value; + } + } + + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 4; + private string requestId_ = ""; + /// + /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the + /// request if it has completed. The server will ignore subsequent requests + /// that provide a duplicate request ID for at least 60 minutes after the first + /// request. + /// + /// For example, if an initial request times out, followed by another request + /// with the same request ID, the server ignores the second request to prevent + /// the creation of duplicate commitments. + /// + /// The request ID must be a valid + /// [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) + /// A zero UUID (00000000-0000-0000-0000-000000000000) is not supported. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as CreateServiceRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(CreateServiceRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Parent != other.Parent) return false; + if (ServiceId != other.ServiceId) return false; + if (!object.Equals(Service, other.Service)) return false; + if (RequestId != other.RequestId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (ServiceId.Length != 0) hash ^= ServiceId.GetHashCode(); + if (service_ != null) hash ^= Service.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (ServiceId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ServiceId); + } + if (service_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Service); + } + if (RequestId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(RequestId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (ServiceId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ServiceId); + } + if (service_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Service); + } + if (RequestId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(RequestId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Parent.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); + } + if (ServiceId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ServiceId); + } + if (service_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Service); + } + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(CreateServiceRequest other) { + if (other == null) { + return; + } + if (other.Parent.Length != 0) { + Parent = other.Parent; + } + if (other.ServiceId.Length != 0) { + ServiceId = other.ServiceId; + } + if (other.service_ != null) { + if (service_ == null) { + Service = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + Service.MergeFrom(other.Service); + } + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Parent = input.ReadString(); + break; + } + case 18: { + ServiceId = input.ReadString(); + break; + } + case 26: { + if (service_ == null) { + Service = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + input.ReadMessage(Service); + break; + } + case 34: { + RequestId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Parent = input.ReadString(); + break; + } + case 18: { + ServiceId = input.ReadString(); + break; + } + case 26: { + if (service_ == null) { + Service = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + input.ReadMessage(Service); + break; + } + case 34: { + RequestId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Request message for [DataprocMetastore.UpdateService][google.cloud.metastore.v1alpha.DataprocMetastore.UpdateService]. + /// + public sealed partial class UpdateServiceRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateServiceRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[16]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public UpdateServiceRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public UpdateServiceRequest(UpdateServiceRequest other) : this() { + updateMask_ = other.updateMask_ != null ? other.updateMask_.Clone() : null; + service_ = other.service_ != null ? other.service_.Clone() : null; + requestId_ = other.requestId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public UpdateServiceRequest Clone() { + return new UpdateServiceRequest(this); + } + + /// Field number for the "update_mask" field. + public const int UpdateMaskFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; + /// + /// Required. A field mask used to specify the fields to be overwritten in the + /// metastore service resource by the update. + /// Fields specified in the `update_mask` are relative to the resource (not + /// to the full request). A field is overwritten if it is in the mask. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { + get { return updateMask_; } + set { + updateMask_ = value; + } + } + + /// Field number for the "service" field. + public const int ServiceFieldNumber = 2; + private global::Google.Cloud.Metastore.V1Alpha.Service service_; + /// + /// Required. The metastore service to update. The server only merges fields + /// in the service if they are specified in `update_mask`. + /// + /// The metastore service's `name` field is used to identify the metastore + /// service to be updated. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.Service Service { + get { return service_; } + set { + service_ = value; + } + } + + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 3; + private string requestId_ = ""; + /// + /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the + /// request if it has completed. The server will ignore subsequent requests + /// that provide a duplicate request ID for at least 60 minutes after the first + /// request. + /// + /// For example, if an initial request times out, followed by another request + /// with the same request ID, the server ignores the second request to prevent + /// the creation of duplicate commitments. + /// + /// The request ID must be a valid + /// [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) + /// A zero UUID (00000000-0000-0000-0000-000000000000) is not supported. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as UpdateServiceRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(UpdateServiceRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(UpdateMask, other.UpdateMask)) return false; + if (!object.Equals(Service, other.Service)) return false; + if (RequestId != other.RequestId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (updateMask_ != null) hash ^= UpdateMask.GetHashCode(); + if (service_ != null) hash ^= Service.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (updateMask_ != null) { + output.WriteRawTag(10); + output.WriteMessage(UpdateMask); + } + if (service_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Service); + } + if (RequestId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(RequestId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (updateMask_ != null) { + output.WriteRawTag(10); + output.WriteMessage(UpdateMask); + } + if (service_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Service); + } + if (RequestId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(RequestId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (updateMask_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateMask); + } + if (service_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Service); + } + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(UpdateServiceRequest other) { + if (other == null) { + return; + } + if (other.updateMask_ != null) { + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + UpdateMask.MergeFrom(other.UpdateMask); + } + if (other.service_ != null) { + if (service_ == null) { + Service = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + Service.MergeFrom(other.Service); + } + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + input.ReadMessage(UpdateMask); + break; + } + case 18: { + if (service_ == null) { + Service = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + input.ReadMessage(Service); + break; + } + case 26: { + RequestId = input.ReadString(); + break; + } + } } + #endif + } - /// - /// A specification of the location of and metadata about a database dump from - /// a relational database management system. - /// - public sealed partial class DatabaseDump : pb::IMessage - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - , pb::IBufferMessage - #endif - { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DatabaseDump()); - private pb::UnknownFieldSet _unknownFields; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Descriptor.NestedTypes[0]; } + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + input.ReadMessage(UpdateMask); + break; + } + case 18: { + if (service_ == null) { + Service = new global::Google.Cloud.Metastore.V1Alpha.Service(); + } + input.ReadMessage(Service); + break; + } + case 26: { + RequestId = input.ReadString(); + break; + } } + } + } + #endif - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - pbr::MessageDescriptor pb::IMessage.Descriptor { - get { return Descriptor; } - } + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public DatabaseDump() { - OnConstruction(); - } + /// + /// Request message for [DataprocMetastore.DeleteService][google.cloud.metastore.v1alpha.DataprocMetastore.DeleteService]. + /// + public sealed partial class DeleteServiceRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeleteServiceRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } - partial void OnConstruction(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[17]; } + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public DatabaseDump(DatabaseDump other) : this() { - databaseType_ = other.databaseType_; - gcsUri_ = other.gcsUri_; - sourceDatabase_ = other.sourceDatabase_; - _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public DatabaseDump Clone() { - return new DatabaseDump(this); - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DeleteServiceRequest() { + OnConstruction(); + } - /// Field number for the "database_type" field. - public const int DatabaseTypeFieldNumber = 1; - private global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType databaseType_ = global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified; - /// - /// The type of the database. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType DatabaseType { - get { return databaseType_; } - set { - databaseType_ = value; - } - } + partial void OnConstruction(); - /// Field number for the "gcs_uri" field. - public const int GcsUriFieldNumber = 2; - private string gcsUri_ = ""; - /// - /// A Cloud Storage object URI that specifies the source from which to - /// import metadata. It must begin with `gs://`. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string GcsUri { - get { return gcsUri_; } - set { - gcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DeleteServiceRequest(DeleteServiceRequest other) : this() { + name_ = other.name_; + requestId_ = other.requestId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } - /// Field number for the "source_database" field. - public const int SourceDatabaseFieldNumber = 3; - private string sourceDatabase_ = ""; - /// - /// The name of the source database. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string SourceDatabase { - get { return sourceDatabase_; } - set { - sourceDatabase_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DeleteServiceRequest Clone() { + return new DeleteServiceRequest(this); + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public override bool Equals(object other) { - return Equals(other as DatabaseDump); - } + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Required. The relative resource name of the metastore service to delete, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(DatabaseDump other) { - if (ReferenceEquals(other, null)) { - return false; - } - if (ReferenceEquals(other, this)) { - return true; - } - if (DatabaseType != other.DatabaseType) return false; - if (GcsUri != other.GcsUri) return false; - if (SourceDatabase != other.SourceDatabase) return false; - return Equals(_unknownFields, other._unknownFields); - } + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 2; + private string requestId_ = ""; + /// + /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the + /// request if it has completed. The server will ignore subsequent requests + /// that provide a duplicate request ID for at least 60 minutes after the first + /// request. + /// + /// For example, if an initial request times out, followed by another request + /// with the same request ID, the server ignores the second request to prevent + /// the creation of duplicate commitments. + /// + /// The request ID must be a valid + /// [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) + /// A zero UUID (00000000-0000-0000-0000-000000000000) is not supported. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public override int GetHashCode() { - int hash = 1; - if (DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) hash ^= DatabaseType.GetHashCode(); - if (GcsUri.Length != 0) hash ^= GcsUri.GetHashCode(); - if (SourceDatabase.Length != 0) hash ^= SourceDatabase.GetHashCode(); - if (_unknownFields != null) { - hash ^= _unknownFields.GetHashCode(); - } - return hash; - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as DeleteServiceRequest); + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public override string ToString() { - return pb::JsonFormatter.ToDiagnosticString(this); - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(DeleteServiceRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (RequestId != other.RequestId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (RequestId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(RequestId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void WriteTo(pb::CodedOutputStream output) { - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - output.WriteRawMessage(this); - #else - if (DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) { - output.WriteRawTag(8); - output.WriteEnum((int) DatabaseType); - } - if (GcsUri.Length != 0) { - output.WriteRawTag(18); - output.WriteString(GcsUri); - } - if (SourceDatabase.Length != 0) { - output.WriteRawTag(26); - output.WriteString(SourceDatabase); - } - if (_unknownFields != null) { - _unknownFields.WriteTo(output); - } - #endif - } + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (RequestId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(RequestId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) { - output.WriteRawTag(8); - output.WriteEnum((int) DatabaseType); - } - if (GcsUri.Length != 0) { - output.WriteRawTag(18); - output.WriteString(GcsUri); - } - if (SourceDatabase.Length != 0) { - output.WriteRawTag(26); - output.WriteString(SourceDatabase); - } - if (_unknownFields != null) { - _unknownFields.WriteTo(ref output); - } - } - #endif + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public int CalculateSize() { - int size = 0; - if (DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) { - size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DatabaseType); - } - if (GcsUri.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(GcsUri); - } - if (SourceDatabase.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(SourceDatabase); - } - if (_unknownFields != null) { - size += _unknownFields.CalculateSize(); - } - return size; - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(DeleteServiceRequest other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void MergeFrom(DatabaseDump other) { - if (other == null) { - return; - } - if (other.DatabaseType != global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType.Unspecified) { - DatabaseType = other.DatabaseType; - } - if (other.GcsUri.Length != 0) { - GcsUri = other.GcsUri; - } - if (other.SourceDatabase.Length != 0) { - SourceDatabase = other.SourceDatabase; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; } - _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void MergeFrom(pb::CodedInputStream input) { - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - input.ReadRawMessage(this); - #else - uint tag; - while ((tag = input.ReadTag()) != 0) { - switch(tag) { - default: - _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); - break; - case 8: { - DatabaseType = (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType) input.ReadEnum(); - break; - } - case 18: { - GcsUri = input.ReadString(); - break; - } - case 26: { - SourceDatabase = input.ReadString(); - break; - } - } + case 18: { + RequestId = input.ReadString(); + break; } - #endif } + } + #endif + } - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { - uint tag; - while ((tag = input.ReadTag()) != 0) { - switch(tag) { - default: - _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); - break; - case 8: { - DatabaseType = (global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Types.DatabaseDump.Types.DatabaseType) input.ReadEnum(); - break; - } - case 18: { - GcsUri = input.ReadString(); - break; - } - case 26: { - SourceDatabase = input.ReadString(); - break; - } - } + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; } - } - #endif - - #region Nested types - /// Container for nested types declared in the DatabaseDump message type. - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static partial class Types { - /// - /// The type of the database. - /// - public enum DatabaseType { - /// - /// The type of the source database is unknown. - /// - [pbr::OriginalName("DATABASE_TYPE_UNSPECIFIED")] Unspecified = 0, - /// - /// The type of the source database is MySQL. - /// - [pbr::OriginalName("MYSQL")] Mysql = 1, + case 18: { + RequestId = input.ReadString(); + break; } - } - #endregion - } - } - #endregion + #endif } /// - /// Request message for [DataprocMetastore.ListServices][google.cloud.metastore.v1alpha.DataprocMetastore.ListServices]. + /// Request message for [DataprocMetastore.ListMetadataImports][google.cloud.metastore.v1alpha.DataprocMetastore.ListMetadataImports]. /// - public sealed partial class ListServicesRequest : pb::IMessage + public sealed partial class ListMetadataImportsRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListServicesRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListMetadataImportsRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[5]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[18]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -2442,14 +6492,14 @@ public sealed partial class ListServicesRequest : pb::IMessageField number for the "parent" field. public const int ParentFieldNumber = 1; private string parent_ = ""; /// - /// Required. The relative resource name of the location of metastore services to + /// Required. The relative resource name of the service whose metadata imports to /// list, in the following form: /// - /// "projects/{project_id}/locations/{location_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public string Parent { @@ -2484,8 +6534,8 @@ public sealed partial class ListServicesRequest : pb::IMessage - /// Optional. The maximum number of services to return. The response may contain less - /// than the maximum number. If unspecified, no more than 500 services are + /// Optional. The maximum number of imports to return. The response may contain less + /// than the maximum number. If unspecified, no more than 500 imports are /// returned. The maximum value is 1000; values above 1000 are changed to 1000. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -2535,9 +6585,9 @@ public sealed partial class ListServicesRequest : pb::IMessage - /// Optional. Specify the ordering of results as described in - /// [Sorting Order](https://cloud.google.com/apis/design/design_patterns#sorting_order). If not - /// specified, the results will be sorted in the default order. + /// Optional. Specify the ordering of results as described in [Sorting + /// Order](https://cloud.google.com/apis/design/design_patterns#sorting_order). + /// If not specified, the results will be sorted in the default order. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public string OrderBy { @@ -2549,11 +6599,11 @@ public sealed partial class ListServicesRequest : pb::IMessage + /// Response message for [DataprocMetastore.ListMetadataImports][google.cloud.metastore.v1alpha.DataprocMetastore.ListMetadataImports]. + /// + public sealed partial class ListMetadataImportsResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListMetadataImportsResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[19]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListMetadataImportsResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListMetadataImportsResponse(ListMetadataImportsResponse other) : this() { + metadataImports_ = other.metadataImports_.Clone(); + nextPageToken_ = other.nextPageToken_; + unreachable_ = other.unreachable_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ListMetadataImportsResponse Clone() { + return new ListMetadataImportsResponse(this); + } + + /// Field number for the "metadata_imports" field. + public const int MetadataImportsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_metadataImports_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Parser); + private readonly pbc::RepeatedField metadataImports_ = new pbc::RepeatedField(); + /// + /// The imports in the specified service. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField MetadataImports { + get { return metadataImports_; } + } + + /// Field number for the "next_page_token" field. + public const int NextPageTokenFieldNumber = 2; + private string nextPageToken_ = ""; + /// + /// A token that can be sent as `page_token` to retrieve the next page. If this + /// field is omitted, there are no subsequent pages. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string NextPageToken { + get { return nextPageToken_; } + set { + nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "unreachable" field. + public const int UnreachableFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_unreachable_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); + /// + /// Locations that could not be reached. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Unreachable { + get { return unreachable_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ListMetadataImportsResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ListMetadataImportsResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!metadataImports_.Equals(other.metadataImports_)) return false; + if (NextPageToken != other.NextPageToken) return false; + if(!unreachable_.Equals(other.unreachable_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= metadataImports_.GetHashCode(); + if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); + hash ^= unreachable_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + metadataImports_.WriteTo(output, _repeated_metadataImports_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); + } + unreachable_.WriteTo(output, _repeated_unreachable_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + metadataImports_.WriteTo(ref output, _repeated_metadataImports_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); + } + unreachable_.WriteTo(ref output, _repeated_unreachable_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += metadataImports_.CalculateSize(_repeated_metadataImports_codec); + if (NextPageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); + } + size += unreachable_.CalculateSize(_repeated_unreachable_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ListMetadataImportsResponse other) { + if (other == null) { + return; } - if (other.OrderBy.Length != 0) { - OrderBy = other.OrderBy; + metadataImports_.Add(other.metadataImports_); + if (other.NextPageToken.Length != 0) { + NextPageToken = other.NextPageToken; } + unreachable_.Add(other.unreachable_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -2706,23 +7007,15 @@ public sealed partial class ListServicesRequest : pb::IMessage - /// Response message for [DataprocMetastore.ListServices][google.cloud.metastore.v1alpha.DataprocMetastore.ListServices]. + /// Request message for [DataprocMetastore.GetMetadataImport][google.cloud.metastore.v1alpha.DataprocMetastore.GetMetadataImport]. /// - public sealed partial class ListServicesResponse : pb::IMessage + public sealed partial class GetMetadataImportRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListServicesResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetMetadataImportRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[6]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[20]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -2790,91 +7075,61 @@ public sealed partial class ListServicesResponse : pb::IMessageField number for the "services" field. - public const int ServicesFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_services_codec - = pb::FieldCodec.ForMessage(10, global::Google.Cloud.Metastore.V1Alpha.Service.Parser); - private readonly pbc::RepeatedField services_ = new pbc::RepeatedField(); - /// - /// The services in the specified location. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public pbc::RepeatedField Services { - get { return services_; } + public GetMetadataImportRequest Clone() { + return new GetMetadataImportRequest(this); } - /// Field number for the "next_page_token" field. - public const int NextPageTokenFieldNumber = 2; - private string nextPageToken_ = ""; + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; /// - /// A token that can be sent as `page_token` to retrieve the next page. If this - /// field is omitted, there are no subsequent pages. + /// Required. The relative resource name of the metadata import to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string NextPageToken { - get { return nextPageToken_; } + public string Name { + get { return name_; } set { - nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "unreachable" field. - public const int UnreachableFieldNumber = 3; - private static readonly pb::FieldCodec _repeated_unreachable_codec - = pb::FieldCodec.ForString(26); - private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); - /// - /// Locations that could not be reached. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public pbc::RepeatedField Unreachable { - get { return unreachable_; } - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as ListServicesResponse); + return Equals(other as GetMetadataImportRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(ListServicesResponse other) { + public bool Equals(GetMetadataImportRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!services_.Equals(other.services_)) return false; - if (NextPageToken != other.NextPageToken) return false; - if(!unreachable_.Equals(other.unreachable_)) return false; + if (Name != other.Name) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - hash ^= services_.GetHashCode(); - if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); - hash ^= unreachable_.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -2891,12 +7146,10 @@ public sealed partial class ListServicesResponse : pb::IMessage - /// Request message for [DataprocMetastore.GetService][google.cloud.metastore.v1alpha.DataprocMetastore.GetService]. + /// Request message for [DataprocMetastore.CreateMetadataImport][google.cloud.metastore.v1alpha.DataprocMetastore.CreateMetadataImport]. /// - public sealed partial class GetServiceRequest : pb::IMessage + public sealed partial class CreateMetadataImportRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetServiceRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateMetadataImportRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[7]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[21]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -3025,61 +7256,130 @@ public sealed partial class GetServiceRequest : pb::IMessage } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public GetServiceRequest() { + public CreateMetadataImportRequest() { OnConstruction(); } partial void OnConstruction(); [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public GetServiceRequest(GetServiceRequest other) : this() { - name_ = other.name_; + public CreateMetadataImportRequest(CreateMetadataImportRequest other) : this() { + parent_ = other.parent_; + metadataImportId_ = other.metadataImportId_; + metadataImport_ = other.metadataImport_ != null ? other.metadataImport_.Clone() : null; + requestId_ = other.requestId_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public GetServiceRequest Clone() { - return new GetServiceRequest(this); + public CreateMetadataImportRequest Clone() { + return new CreateMetadataImportRequest(this); } - /// Field number for the "name" field. - public const int NameFieldNumber = 1; - private string name_ = ""; + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; /// - /// Required. The relative resource name of the metastore service to retrieve, in the - /// following form: + /// Required. The relative resource name of the service in which to create a metastore + /// import, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "metadata_import_id" field. + public const int MetadataImportIdFieldNumber = 2; + private string metadataImportId_ = ""; + /// + /// Required. The ID of the metadata import, which is used as the final component of the + /// metadata import's name. + /// + /// This value must be between 1 and 64 characters long, begin with a letter, + /// end with a letter or number, and consist of alpha-numeric ASCII characters + /// or hyphens. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string MetadataImportId { + get { return metadataImportId_; } + set { + metadataImportId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "metadata_import" field. + public const int MetadataImportFieldNumber = 3; + private global::Google.Cloud.Metastore.V1Alpha.MetadataImport metadataImport_; + /// + /// Required. The metadata import to create. The `name` field is ignored. The ID of the + /// created metadata import must be provided in the request's + /// `metadata_import_id` field. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.MetadataImport MetadataImport { + get { return metadataImport_; } + set { + metadataImport_ = value; + } + } + + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 4; + private string requestId_ = ""; + /// + /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the + /// request if it has completed. The server will ignore subsequent requests + /// that provide a duplicate request ID for at least 60 minutes after the first + /// request. + /// + /// For example, if an initial request times out, followed by another request + /// with the same request ID, the server ignores the second request to prevent + /// the creation of duplicate commitments. /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// The request ID must be a valid + /// [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) + /// A zero UUID (00000000-0000-0000-0000-000000000000) is not supported. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Name { - get { return name_; } + public string RequestId { + get { return requestId_; } set { - name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as GetServiceRequest); + return Equals(other as CreateMetadataImportRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(GetServiceRequest other) { + public bool Equals(CreateMetadataImportRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Name != other.Name) return false; + if (Parent != other.Parent) return false; + if (MetadataImportId != other.MetadataImportId) return false; + if (!object.Equals(MetadataImport, other.MetadataImport)) return false; + if (RequestId != other.RequestId) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (MetadataImportId.Length != 0) hash ^= MetadataImportId.GetHashCode(); + if (metadataImport_ != null) hash ^= MetadataImport.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -3096,9 +7396,21 @@ public sealed partial class GetServiceRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Name.Length != 0) { + if (Parent.Length != 0) { output.WriteRawTag(10); - output.WriteString(Name); + output.WriteString(Parent); + } + if (MetadataImportId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(MetadataImportId); + } + if (metadataImport_ != null) { + output.WriteRawTag(26); + output.WriteMessage(MetadataImport); + } + if (RequestId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(RequestId); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -3109,9 +7421,21 @@ public sealed partial class GetServiceRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE [global::System.Diagnostics.DebuggerNonUserCodeAttribute] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Name.Length != 0) { + if (Parent.Length != 0) { output.WriteRawTag(10); - output.WriteString(Name); + output.WriteString(Parent); + } + if (MetadataImportId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(MetadataImportId); + } + if (metadataImport_ != null) { + output.WriteRawTag(26); + output.WriteMessage(MetadataImport); + } + if (RequestId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(RequestId); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -3122,8 +7446,17 @@ public sealed partial class GetServiceRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public int CalculateSize() { int size = 0; - if (Name.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + if (Parent.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); + } + if (MetadataImportId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MetadataImportId); + } + if (metadataImport_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(MetadataImport); + } + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -3132,12 +7465,24 @@ public sealed partial class GetServiceRequest : pb::IMessage } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public void MergeFrom(GetServiceRequest other) { + public void MergeFrom(CreateMetadataImportRequest other) { if (other == null) { return; } - if (other.Name.Length != 0) { - Name = other.Name; + if (other.Parent.Length != 0) { + Parent = other.Parent; + } + if (other.MetadataImportId.Length != 0) { + MetadataImportId = other.MetadataImportId; + } + if (other.metadataImport_ != null) { + if (metadataImport_ == null) { + MetadataImport = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport(); + } + MetadataImport.MergeFrom(other.MetadataImport); + } + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -3154,7 +7499,22 @@ public sealed partial class GetServiceRequest : pb::IMessage _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Name = input.ReadString(); + Parent = input.ReadString(); + break; + } + case 18: { + MetadataImportId = input.ReadString(); + break; + } + case 26: { + if (metadataImport_ == null) { + MetadataImport = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport(); + } + input.ReadMessage(MetadataImport); + break; + } + case 34: { + RequestId = input.ReadString(); break; } } @@ -3172,7 +7532,22 @@ public sealed partial class GetServiceRequest : pb::IMessage _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Name = input.ReadString(); + Parent = input.ReadString(); + break; + } + case 18: { + MetadataImportId = input.ReadString(); + break; + } + case 26: { + if (metadataImport_ == null) { + MetadataImport = new global::Google.Cloud.Metastore.V1Alpha.MetadataImport(); + } + input.ReadMessage(MetadataImport); + break; + } + case 34: { + RequestId = input.ReadString(); break; } } @@ -3183,21 +7558,21 @@ public sealed partial class GetServiceRequest : pb::IMessage } /// - /// Request message for [DataprocMetastore.CreateService][google.cloud.metastore.v1alpha.DataprocMetastore.CreateService]. + /// Request message for [DataprocMetastore.UpdateMetadataImport][google.cloud.metastore.v1alpha.DataprocMetastore.UpdateMetadataImport]. /// - public sealed partial class CreateServiceRequest : pb::IMessage + public sealed partial class UpdateMetadataImportRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateServiceRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateMetadataImportRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[8]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[22]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -3206,80 +7581,62 @@ public sealed partial class CreateServiceRequest : pb::IMessageField number for the "parent" field. - public const int ParentFieldNumber = 1; - private string parent_ = ""; + /// Field number for the "update_mask" field. + public const int UpdateMaskFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; /// - /// Required. The relative resource name of the location in which to create a metastore - /// service, in the following form: - /// - /// "projects/{project_id}/locations/{location_id}". + /// Required. A field mask used to specify the fields to be overwritten in the + /// metadata import resource by the update. + /// Fields specified in the `update_mask` are relative to the resource (not + /// to the full request). A field is overwritten if it is in the mask. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Parent { - get { return parent_; } + public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { + get { return updateMask_; } set { - parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + updateMask_ = value; } } - /// Field number for the "service_id" field. - public const int ServiceIdFieldNumber = 2; - private string serviceId_ = ""; + /// Field number for the "metadata_import" field. + public const int MetadataImportFieldNumber = 2; + private global::Google.Cloud.Metastore.V1Alpha.MetadataImport metadataImport_; /// - /// Required. The ID of the metastore service, which is used as the final - /// component of the metastore service's name. + /// Required. The metadata import to update. The server only merges fields + /// in the import if they are specified in `update_mask`. /// - /// This value must be between 1 and 64 characters long, begin with a - /// letter, end with a letter or number, and consist of alpha-numeric - /// ASCII characters or hyphens. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string ServiceId { - get { return serviceId_; } - set { - serviceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - - /// Field number for the "service" field. - public const int ServiceFieldNumber = 3; - private global::Google.Cloud.Metastore.V1Alpha.Service service_; - /// - /// Required. The Metastore service to create. The `name` field is - /// ignored. The ID of the created metastore service must be provided in - /// the request's `service_id` field. + /// The metadata import's `name` field is used to identify the metastore + /// import to be updated. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.Service Service { - get { return service_; } + public global::Google.Cloud.Metastore.V1Alpha.MetadataImport MetadataImport { + get { return metadataImport_; } set { - service_ = value; + metadataImport_ = value; } } /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 4; + public const int RequestIdFieldNumber = 3; private string requestId_ = ""; /// /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the @@ -3305,20 +7662,19 @@ public sealed partial class CreateServiceRequest : pb::IMessage - /// Request message for [DataprocMetastore.UpdateService][google.cloud.metastore.v1alpha.DataprocMetastore.UpdateService]. + /// Request message for [DataprocMetastore.ListBackups][google.cloud.metastore.v1alpha.DataprocMetastore.ListBackups]. /// - public sealed partial class UpdateServiceRequest : pb::IMessage + public sealed partial class ListBackupsRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateServiceRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListBackupsRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[9]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[23]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -3531,110 +7873,140 @@ public sealed partial class UpdateServiceRequest : pb::IMessageField number for the "update_mask" field. - public const int UpdateMaskFieldNumber = 1; - private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; /// - /// Required. A field mask used to specify the fields to be overwritten in the - /// metastore service resource by the update. - /// Fields specified in the `update_mask` are relative to the resource (not - /// to the full request). A field is overwritten if it is in the mask. + /// Required. The relative resource name of the service whose backups to + /// list, in the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { - get { return updateMask_; } + public string Parent { + get { return parent_; } set { - updateMask_ = value; + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "service" field. - public const int ServiceFieldNumber = 2; - private global::Google.Cloud.Metastore.V1Alpha.Service service_; + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 2; + private int pageSize_; /// - /// Required. The metastore service to update. The server only merges fields - /// in the service if they are specified in `update_mask`. - /// - /// The metastore service's `name` field is used to identify the metastore - /// service to be updated. + /// Optional. The maximum number of backups to return. The response may contain less + /// than the maximum number. If unspecified, no more than 500 backups are + /// returned. The maximum value is 1000; values above 1000 are changed to 1000. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.Service Service { - get { return service_; } + public int PageSize { + get { return pageSize_; } set { - service_ = value; + pageSize_ = value; } } - /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 3; - private string requestId_ = ""; + /// Field number for the "page_token" field. + public const int PageTokenFieldNumber = 3; + private string pageToken_ = ""; /// - /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the - /// request if it has completed. The server will ignore subsequent requests - /// that provide a duplicate request ID for at least 60 minutes after the first - /// request. + /// Optional. A page token, received from a previous [DataprocMetastore.ListBackups][google.cloud.metastore.v1alpha.DataprocMetastore.ListBackups] + /// call. Provide this token to retrieve the subsequent page. /// - /// For example, if an initial request times out, followed by another request - /// with the same request ID, the server ignores the second request to prevent - /// the creation of duplicate commitments. + /// To retrieve the first page, supply an empty page token. /// - /// The request ID must be a valid - /// [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) - /// A zero UUID (00000000-0000-0000-0000-000000000000) is not supported. + /// When paginating, other parameters provided to + /// [DataprocMetastore.ListBackups][google.cloud.metastore.v1alpha.DataprocMetastore.ListBackups] must match the call that provided the + /// page token. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string RequestId { - get { return requestId_; } + public string PageToken { + get { return pageToken_; } set { - requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "filter" field. + public const int FilterFieldNumber = 4; + private string filter_ = ""; + /// + /// Optional. The filter to apply to list results. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Filter { + get { return filter_; } + set { + filter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "order_by" field. + public const int OrderByFieldNumber = 5; + private string orderBy_ = ""; + /// + /// Optional. Specify the ordering of results as described in [Sorting + /// Order](https://cloud.google.com/apis/design/design_patterns#sorting_order). + /// If not specified, the results will be sorted in the default order. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string OrderBy { + get { return orderBy_; } + set { + orderBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as UpdateServiceRequest); + return Equals(other as ListBackupsRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(UpdateServiceRequest other) { + public bool Equals(ListBackupsRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(UpdateMask, other.UpdateMask)) return false; - if (!object.Equals(Service, other.Service)) return false; - if (RequestId != other.RequestId) return false; + if (Parent != other.Parent) return false; + if (PageSize != other.PageSize) return false; + if (PageToken != other.PageToken) return false; + if (Filter != other.Filter) return false; + if (OrderBy != other.OrderBy) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (updateMask_ != null) hash ^= UpdateMask.GetHashCode(); - if (service_ != null) hash ^= Service.GetHashCode(); - if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); + if (Filter.Length != 0) hash ^= Filter.GetHashCode(); + if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -3651,17 +8023,25 @@ public sealed partial class UpdateServiceRequest : pb::IMessage - /// Request message for [DataprocMetastore.DeleteService][google.cloud.metastore.v1alpha.DataprocMetastore.DeleteService]. + /// Response message for [DataprocMetastore.ListBackups][google.cloud.metastore.v1alpha.DataprocMetastore.ListBackups]. /// - public sealed partial class DeleteServiceRequest : pb::IMessage + public sealed partial class ListBackupsResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeleteServiceRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListBackupsResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[10]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[24]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -3823,89 +8221,91 @@ public sealed partial class DeleteServiceRequest : pb::IMessageField number for the "name" field. - public const int NameFieldNumber = 1; - private string name_ = ""; + /// Field number for the "backups" field. + public const int BackupsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_backups_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.Metastore.V1Alpha.Backup.Parser); + private readonly pbc::RepeatedField backups_ = new pbc::RepeatedField(); /// - /// Required. The relative resource name of the metastore service to delete, in the - /// following form: - /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}". + /// The backups of the specified service. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Name { - get { return name_; } - set { - name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + public pbc::RepeatedField Backups { + get { return backups_; } } - /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 2; - private string requestId_ = ""; + /// Field number for the "next_page_token" field. + public const int NextPageTokenFieldNumber = 2; + private string nextPageToken_ = ""; /// - /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the - /// request if it has completed. The server will ignore subsequent requests - /// that provide a duplicate request ID for at least 60 minutes after the first - /// request. - /// - /// For example, if an initial request times out, followed by another request - /// with the same request ID, the server ignores the second request to prevent - /// the creation of duplicate commitments. - /// - /// The request ID must be a valid - /// [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) - /// A zero UUID (00000000-0000-0000-0000-000000000000) is not supported. + /// A token that can be sent as `page_token` to retrieve the next page. If this + /// field is omitted, there are no subsequent pages. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string RequestId { - get { return requestId_; } + public string NextPageToken { + get { return nextPageToken_; } set { - requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } + /// Field number for the "unreachable" field. + public const int UnreachableFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_unreachable_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); + /// + /// Locations that could not be reached. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Unreachable { + get { return unreachable_; } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as DeleteServiceRequest); + return Equals(other as ListBackupsResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(DeleteServiceRequest other) { + public bool Equals(ListBackupsResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Name != other.Name) return false; - if (RequestId != other.RequestId) return false; + if(!backups_.Equals(other.backups_)) return false; + if (NextPageToken != other.NextPageToken) return false; + if(!unreachable_.Equals(other.unreachable_)) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (Name.Length != 0) hash ^= Name.GetHashCode(); - if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + hash ^= backups_.GetHashCode(); + if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); + hash ^= unreachable_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -3922,14 +8322,12 @@ public sealed partial class DeleteServiceRequest : pb::IMessage - /// Request message for [DataprocMetastore.ListMetadataImports][google.cloud.metastore.v1alpha.DataprocMetastore.ListMetadataImports]. + /// Request message for [DataprocMetastore.GetBackup][google.cloud.metastore.v1alpha.DataprocMetastore.GetBackup]. /// - public sealed partial class ListMetadataImportsRequest : pb::IMessage + public sealed partial class GetBackupRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListMetadataImportsRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetBackupRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[11]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[25]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4054,140 +8456,61 @@ public sealed partial class ListMetadataImportsRequest : pb::IMessageField number for the "parent" field. - public const int ParentFieldNumber = 1; - private string parent_ = ""; - /// - /// Required. The relative resource name of the service whose metadata imports to - /// list, in the following form: - /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports". - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Parent { - get { return parent_; } - set { - parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - - /// Field number for the "page_size" field. - public const int PageSizeFieldNumber = 2; - private int pageSize_; - /// - /// Optional. The maximum number of imports to return. The response may contain less - /// than the maximum number. If unspecified, no more than 500 imports are - /// returned. The maximum value is 1000; values above 1000 are changed to 1000. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public int PageSize { - get { return pageSize_; } - set { - pageSize_ = value; - } - } - - /// Field number for the "page_token" field. - public const int PageTokenFieldNumber = 3; - private string pageToken_ = ""; - /// - /// Optional. A page token, received from a previous [DataprocMetastore.ListServices][google.cloud.metastore.v1alpha.DataprocMetastore.ListServices] - /// call. Provide this token to retrieve the subsequent page. - /// - /// To retrieve the first page, supply an empty page token. - /// - /// When paginating, other parameters provided to - /// [DataprocMetastore.ListServices][google.cloud.metastore.v1alpha.DataprocMetastore.ListServices] must match the call that provided the - /// page token. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string PageToken { - get { return pageToken_; } - set { - pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetBackupRequest(GetBackupRequest other) : this() { + name_ = other.name_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } - /// Field number for the "filter" field. - public const int FilterFieldNumber = 4; - private string filter_ = ""; - /// - /// Optional. The filter to apply to list results. - /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Filter { - get { return filter_; } - set { - filter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + public GetBackupRequest Clone() { + return new GetBackupRequest(this); } - /// Field number for the "order_by" field. - public const int OrderByFieldNumber = 5; - private string orderBy_ = ""; + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; /// - /// Optional. Specify the ordering of results as described in - /// [Sorting Order](https://cloud.google.com/apis/design/design_patterns#sorting_order). If not - /// specified, the results will be sorted in the default order. + /// Required. The relative resource name of the backup to retrieve, in the + /// following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string OrderBy { - get { return orderBy_; } + public string Name { + get { return name_; } set { - orderBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as ListMetadataImportsRequest); + return Equals(other as GetBackupRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(ListMetadataImportsRequest other) { + public bool Equals(GetBackupRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Parent != other.Parent) return false; - if (PageSize != other.PageSize) return false; - if (PageToken != other.PageToken) return false; - if (Filter != other.Filter) return false; - if (OrderBy != other.OrderBy) return false; + if (Name != other.Name) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (Parent.Length != 0) hash ^= Parent.GetHashCode(); - if (PageSize != 0) hash ^= PageSize.GetHashCode(); - if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); - if (Filter.Length != 0) hash ^= Filter.GetHashCode(); - if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4204,25 +8527,9 @@ public sealed partial class ListMetadataImportsRequest : pb::IMessage - /// Response message for [DataprocMetastore.ListMetadataImports][google.cloud.metastore.v1alpha.DataprocMetastore.ListMetadataImports]. + /// Request message for [DataprocMetastore.CreateBackup][google.cloud.metastore.v1alpha.DataprocMetastore.CreateBackup]. /// - public sealed partial class ListMetadataImportsResponse : pb::IMessage + public sealed partial class CreateBackupRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListMetadataImportsResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateBackupRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[12]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[26]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4402,91 +8637,129 @@ public sealed partial class ListMetadataImportsResponse : pb::IMessageField number for the "metadata_imports" field. - public const int MetadataImportsFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_metadataImports_codec - = pb::FieldCodec.ForMessage(10, global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Parser); - private readonly pbc::RepeatedField metadataImports_ = new pbc::RepeatedField(); + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; /// - /// The imports in the specified service. + /// Required. The relative resource name of the service in which to create a backup + /// of the following form: + /// + /// `projects/{project_number}/locations/{location_id}/services/{service_id}` /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public pbc::RepeatedField MetadataImports { - get { return metadataImports_; } + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } } - /// Field number for the "next_page_token" field. - public const int NextPageTokenFieldNumber = 2; - private string nextPageToken_ = ""; + /// Field number for the "backup_id" field. + public const int BackupIdFieldNumber = 2; + private string backupId_ = ""; /// - /// A token that can be sent as `page_token` to retrieve the next page. If this - /// field is omitted, there are no subsequent pages. + /// Required. The ID of the backup, which is used as the final component of the + /// backup's name. + /// + /// This value must be between 1 and 64 characters long, begin with a letter, + /// end with a letter or number, and consist of alpha-numeric ASCII characters + /// or hyphens. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string NextPageToken { - get { return nextPageToken_; } + public string BackupId { + get { return backupId_; } set { - nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + backupId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "unreachable" field. - public const int UnreachableFieldNumber = 3; - private static readonly pb::FieldCodec _repeated_unreachable_codec - = pb::FieldCodec.ForString(26); - private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); + /// Field number for the "backup" field. + public const int BackupFieldNumber = 3; + private global::Google.Cloud.Metastore.V1Alpha.Backup backup_; /// - /// Locations that could not be reached. + /// Required. The backup to create. The `name` field is ignored. The ID of the created + /// backup must be provided in the request's `backup_id` field. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public pbc::RepeatedField Unreachable { - get { return unreachable_; } + public global::Google.Cloud.Metastore.V1Alpha.Backup Backup { + get { return backup_; } + set { + backup_ = value; + } + } + + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 4; + private string requestId_ = ""; + /// + /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the + /// request if it has completed. The server will ignore subsequent requests + /// that provide a duplicate request ID for at least 60 minutes after the first + /// request. + /// + /// For example, if an initial request times out, followed by another request + /// with the same request ID, the server ignores the second request to prevent + /// the creation of duplicate commitments. + /// + /// The request ID must be a valid + /// [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) + /// A zero UUID (00000000-0000-0000-0000-000000000000) is not supported. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as ListMetadataImportsResponse); + return Equals(other as CreateBackupRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(ListMetadataImportsResponse other) { + public bool Equals(CreateBackupRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!metadataImports_.Equals(other.metadataImports_)) return false; - if (NextPageToken != other.NextPageToken) return false; - if(!unreachable_.Equals(other.unreachable_)) return false; + if (Parent != other.Parent) return false; + if (BackupId != other.BackupId) return false; + if (!object.Equals(Backup, other.Backup)) return false; + if (RequestId != other.RequestId) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - hash ^= metadataImports_.GetHashCode(); - if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); - hash ^= unreachable_.GetHashCode(); + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (BackupId.Length != 0) hash ^= BackupId.GetHashCode(); + if (backup_ != null) hash ^= Backup.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4503,12 +8776,22 @@ public sealed partial class ListMetadataImportsResponse : pb::IMessage - /// Request message for [DataprocMetastore.GetMetadataImport][google.cloud.metastore.v1alpha.DataprocMetastore.GetMetadataImport]. + /// Request message for [DataprocMetastore.DeleteBackup][google.cloud.metastore.v1alpha.DataprocMetastore.DeleteBackup]. /// - public sealed partial class GetMetadataImportRequest : pb::IMessage + public sealed partial class DeleteBackupRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetMetadataImportRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeleteBackupRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[13]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[27]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4637,31 +8961,32 @@ public sealed partial class GetMetadataImportRequest : pb::IMessageField number for the "name" field. public const int NameFieldNumber = 1; private string name_ = ""; /// - /// Required. The relative resource name of the metadata import to retrieve, in the + /// Required. The relative resource name of the backup to delete, in the /// following form: /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}/metadataImports/{import_id}". + /// `projects/{project_number}/locations/{location_id}/services/{service_id}/backups/{backup_id}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public string Name { @@ -4671,13 +8996,38 @@ public sealed partial class GetMetadataImportRequest : pb::IMessageField number for the "request_id" field. + public const int RequestIdFieldNumber = 2; + private string requestId_ = ""; + /// + /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the + /// request if it has completed. The server will ignore subsequent requests + /// that provide a duplicate request ID for at least 60 minutes after the first + /// request. + /// + /// For example, if an initial request times out, followed by another request + /// with the same request ID, the server ignores the second request to prevent + /// the creation of duplicate commitments. + /// + /// The request ID must be a valid + /// [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) + /// A zero UUID (00000000-0000-0000-0000-000000000000) is not supported. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as GetMetadataImportRequest); + return Equals(other as DeleteBackupRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(GetMetadataImportRequest other) { + public bool Equals(DeleteBackupRequest other) { if (ReferenceEquals(other, null)) { return false; } @@ -4685,6 +9035,7 @@ public sealed partial class GetMetadataImportRequest : pb::IMessage - /// Request message for [DataprocMetastore.CreateMetadataImport][google.cloud.metastore.v1alpha.DataprocMetastore.CreateMetadataImport]. + /// Request message for [DataprocMetastore.ExportMetadata][google.cloud.metastore.v1alpha.DataprocMetastore.ExportMetadata]. /// - public sealed partial class CreateMetadataImportRequest : pb::IMessage + public sealed partial class ExportMetadataRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateMetadataImportRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ExportMetadataRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[14]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[28]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4818,80 +9192,66 @@ public sealed partial class CreateMetadataImportRequest : pb::IMessageField number for the "parent" field. - public const int ParentFieldNumber = 1; - private string parent_ = ""; + /// Field number for the "destination_gcs_folder" field. + public const int DestinationGcsFolderFieldNumber = 2; /// - /// Required. The relative resource name of the service in which to create a metastore - /// import, in the following form: - /// - /// "projects/{project_id}/locations/{location_id}/services/{service_id}" + /// A Cloud Storage URI of a folder, in the format + /// `gs://<bucket_name>/<path_inside_bucket>`. A sub-folder + /// `<export_folder>` containing exported files will be created below it. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string Parent { - get { return parent_; } + public string DestinationGcsFolder { + get { return destinationCase_ == DestinationOneofCase.DestinationGcsFolder ? (string) destination_ : ""; } set { - parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + destination_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + destinationCase_ = DestinationOneofCase.DestinationGcsFolder; } } - /// Field number for the "metadata_import_id" field. - public const int MetadataImportIdFieldNumber = 2; - private string metadataImportId_ = ""; + /// Field number for the "service" field. + public const int ServiceFieldNumber = 1; + private string service_ = ""; /// - /// Required. The ID of the metadata import, which is used as the final component of the - /// metadata import's name. + /// Required. The relative resource name of the metastore service to run export, in the + /// following form: /// - /// This value must be between 1 and 64 characters long, begin with a letter, - /// end with a letter or number, and consist of alpha-numeric ASCII characters - /// or hyphens. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public string MetadataImportId { - get { return metadataImportId_; } - set { - metadataImportId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - - /// Field number for the "metadata_import" field. - public const int MetadataImportFieldNumber = 3; - private global::Google.Cloud.Metastore.V1Alpha.MetadataImport metadataImport_; - /// - /// Required. The metadata import to create. The `name` field is ignored. The ID of the - /// created metadata import must be provided in the request's - /// `metadata_import_id` field. + /// `projects/{project_id}/locations/{location_id}/services/{service_id}` /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.MetadataImport MetadataImport { - get { return metadataImport_; } + public string Service { + get { return service_; } set { - metadataImport_ = value; + service_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 4; + public const int RequestIdFieldNumber = 3; private string requestId_ = ""; /// /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the @@ -4904,7 +9264,7 @@ public sealed partial class CreateMetadataImportRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4915,33 +9275,67 @@ public sealed partial class CreateMetadataImportRequest : pb::IMessageField number for the "database_dump_type" field. + public const int DatabaseDumpTypeFieldNumber = 4; + private global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type databaseDumpType_ = global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified; + /// + /// Optional. The type of the database dump. If unspecified, defaults to `MYSQL`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type DatabaseDumpType { + get { return databaseDumpType_; } + set { + databaseDumpType_ = value; + } + } + + private object destination_; + /// Enum of possible cases for the "destination" oneof. + public enum DestinationOneofCase { + None = 0, + DestinationGcsFolder = 2, + } + private DestinationOneofCase destinationCase_ = DestinationOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DestinationOneofCase DestinationCase { + get { return destinationCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void ClearDestination() { + destinationCase_ = DestinationOneofCase.None; + destination_ = null; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override bool Equals(object other) { - return Equals(other as CreateMetadataImportRequest); + return Equals(other as ExportMetadataRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public bool Equals(CreateMetadataImportRequest other) { + public bool Equals(ExportMetadataRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Parent != other.Parent) return false; - if (MetadataImportId != other.MetadataImportId) return false; - if (!object.Equals(MetadataImport, other.MetadataImport)) return false; + if (DestinationGcsFolder != other.DestinationGcsFolder) return false; + if (Service != other.Service) return false; if (RequestId != other.RequestId) return false; + if (DatabaseDumpType != other.DatabaseDumpType) return false; + if (DestinationCase != other.DestinationCase) return false; return Equals(_unknownFields, other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; - if (Parent.Length != 0) hash ^= Parent.GetHashCode(); - if (MetadataImportId.Length != 0) hash ^= MetadataImportId.GetHashCode(); - if (metadataImport_ != null) hash ^= MetadataImport.GetHashCode(); + if (destinationCase_ == DestinationOneofCase.DestinationGcsFolder) hash ^= DestinationGcsFolder.GetHashCode(); + if (Service.Length != 0) hash ^= Service.GetHashCode(); if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + if (DatabaseDumpType != global::Google.Cloud.Metastore.V1Alpha.DatabaseDumpSpec.Types.Type.Unspecified) hash ^= DatabaseDumpType.GetHashCode(); + hash ^= (int) destinationCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4958,22 +9352,22 @@ public sealed partial class CreateMetadataImportRequest : pb::IMessage - /// Request message for [DataprocMetastore.UpdateMetadataImport][google.cloud.metastore.v1alpha.DataprocMetastore.UpdateMetadataImport]. + /// Request message for [DataprocMetastore.Restore][]. /// - public sealed partial class UpdateMetadataImportRequest : pb::IMessage + public sealed partial class RestoreServiceRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateMetadataImportRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RestoreServiceRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[15]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[29]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5143,62 +9531,76 @@ public sealed partial class UpdateMetadataImportRequest : pb::IMessageField number for the "update_mask" field. - public const int UpdateMaskFieldNumber = 1; - private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; + /// Field number for the "service" field. + public const int ServiceFieldNumber = 1; + private string service_ = ""; /// - /// Required. A field mask used to specify the fields to be overwritten in the - /// metadata import resource by the update. - /// Fields specified in the `update_mask` are relative to the resource (not - /// to the full request). A field is overwritten if it is in the mask. + /// Required. The relative resource name of the metastore service to run restore, in the + /// following form: + /// + /// `projects/{project_id}/locations/{location_id}/services/{service_id}` /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { - get { return updateMask_; } + public string Service { + get { return service_; } set { - updateMask_ = value; + service_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "metadata_import" field. - public const int MetadataImportFieldNumber = 2; - private global::Google.Cloud.Metastore.V1Alpha.MetadataImport metadataImport_; + /// Field number for the "backup" field. + public const int BackupFieldNumber = 2; + private string backup_ = ""; /// - /// Required. The metadata import to update. The server only merges fields - /// in the import if they are specified in `update_mask`. + /// Required. The relative resource name of the metastore service backup to restore + /// from, in the following form: /// - /// The metadata import's `name` field is used to identify the metastore - /// import to be updated. + /// `projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}` /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - public global::Google.Cloud.Metastore.V1Alpha.MetadataImport MetadataImport { - get { return metadataImport_; } + public string Backup { + get { return backup_; } set { - metadataImport_ = value; + backup_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "restore_type" field. + public const int RestoreTypeFieldNumber = 3; + private global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType restoreType_ = global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType.Unspecified; + /// + /// Optional. The type of restore. If unspecified, defaults to `METADATA_ONLY`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Cloud.Metastore.V1Alpha.Restore.Types.RestoreType RestoreType { + get { return restoreType_; } + set { + restoreType_ = value; } } /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 3; + public const int RequestIdFieldNumber = 4; private string requestId_ = ""; /// /// Optional. A request ID. Specify a unique request ID to allow the server to ignore the @@ -5211,7 +9613,7 @@ public sealed partial class UpdateMetadataImportRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5224,19 +9626,20 @@ public sealed partial class UpdateMetadataImportRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[16]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[30]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5859,7 +10267,7 @@ public sealed partial class LocationMetadata : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[17]; } + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[31]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6238,6 +10646,166 @@ public sealed partial class HiveMetastoreVersion : pb::IMessage + /// The specification of database dump to import from or export to. + /// + public sealed partial class DatabaseDumpSpec : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DatabaseDumpSpec()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Metastore.V1Alpha.MetastoreReflection.Descriptor.MessageTypes[32]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DatabaseDumpSpec() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DatabaseDumpSpec(DatabaseDumpSpec other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DatabaseDumpSpec Clone() { + return new DatabaseDumpSpec(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as DatabaseDumpSpec); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(DatabaseDumpSpec other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(DatabaseDumpSpec other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the DatabaseDumpSpec message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// The type of the database dump. + /// + public enum Type { + /// + /// The type of the database dump is unknown. + /// + [pbr::OriginalName("TYPE_UNSPECIFIED")] Unspecified = 0, + /// + /// Database dump is a MySQL dump file. + /// + [pbr::OriginalName("MYSQL")] Mysql = 1, + } + + } + #endregion + + } + #endregion } diff --git a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/MetastoreGrpc.cs b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/MetastoreGrpc.cs index 49c143e41b57..116ecd8006e2 100644 --- a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/MetastoreGrpc.cs +++ b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/MetastoreGrpc.cs @@ -3,7 +3,7 @@ // source: google/cloud/metastore/v1alpha/metastore.proto // // Original file comments: -// Copyright 2020 Google LLC +// Copyright 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -40,7 +40,7 @@ namespace Google.Cloud.Metastore.V1Alpha { /// * Each location has a collection of services, named: `/services/*` /// * Dataproc Metastore services are resources with names of the form: /// - /// `/projects/{project_id}/locations/{location_id}/services/{service_id}`. + /// `/projects/{project_number}/locations/{location_id}/services/{service_id}`. /// public static partial class DataprocMetastore { @@ -60,6 +60,14 @@ public static partial class DataprocMetastore static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_MetadataImport = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.MetadataImport.Parser.ParseFrom); static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_CreateMetadataImportRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.CreateMetadataImportRequest.Parser.ParseFrom); static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_UpdateMetadataImportRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.UpdateMetadataImportRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_ExportMetadataRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.ExportMetadataRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_RestoreServiceRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.RestoreServiceRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_ListBackupsRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.ListBackupsRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_ListBackupsResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.ListBackupsResponse.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_GetBackupRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.GetBackupRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_Backup = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.Backup.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_CreateBackupRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.CreateBackupRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_google_cloud_metastore_v1alpha_DeleteBackupRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Cloud.Metastore.V1Alpha.DeleteBackupRequest.Parser.ParseFrom); static readonly grpc::Method __Method_ListServices = new grpc::Method( grpc::MethodType.Unary, @@ -124,6 +132,48 @@ public static partial class DataprocMetastore __Marshaller_google_cloud_metastore_v1alpha_UpdateMetadataImportRequest, __Marshaller_google_longrunning_Operation); + static readonly grpc::Method __Method_ExportMetadata = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ExportMetadata", + __Marshaller_google_cloud_metastore_v1alpha_ExportMetadataRequest, + __Marshaller_google_longrunning_Operation); + + static readonly grpc::Method __Method_RestoreService = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "RestoreService", + __Marshaller_google_cloud_metastore_v1alpha_RestoreServiceRequest, + __Marshaller_google_longrunning_Operation); + + static readonly grpc::Method __Method_ListBackups = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ListBackups", + __Marshaller_google_cloud_metastore_v1alpha_ListBackupsRequest, + __Marshaller_google_cloud_metastore_v1alpha_ListBackupsResponse); + + static readonly grpc::Method __Method_GetBackup = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "GetBackup", + __Marshaller_google_cloud_metastore_v1alpha_GetBackupRequest, + __Marshaller_google_cloud_metastore_v1alpha_Backup); + + static readonly grpc::Method __Method_CreateBackup = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "CreateBackup", + __Marshaller_google_cloud_metastore_v1alpha_CreateBackupRequest, + __Marshaller_google_longrunning_Operation); + + static readonly grpc::Method __Method_DeleteBackup = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "DeleteBackup", + __Marshaller_google_cloud_metastore_v1alpha_DeleteBackupRequest, + __Marshaller_google_longrunning_Operation); + /// Service descriptor public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor { @@ -234,6 +284,72 @@ public abstract partial class DataprocMetastoreBase throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); } + /// + /// Exports metadata from a service. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + public virtual global::System.Threading.Tasks.Task ExportMetadata(global::Google.Cloud.Metastore.V1Alpha.ExportMetadataRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Restores a service from a backup. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + public virtual global::System.Threading.Tasks.Task RestoreService(global::Google.Cloud.Metastore.V1Alpha.RestoreServiceRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Lists backups in a service. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + public virtual global::System.Threading.Tasks.Task ListBackups(global::Google.Cloud.Metastore.V1Alpha.ListBackupsRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Gets details of a single backup. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + public virtual global::System.Threading.Tasks.Task GetBackup(global::Google.Cloud.Metastore.V1Alpha.GetBackupRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Creates a new Backup in a given project and location. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + public virtual global::System.Threading.Tasks.Task CreateBackup(global::Google.Cloud.Metastore.V1Alpha.CreateBackupRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Deletes a single backup. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + public virtual global::System.Threading.Tasks.Task DeleteBackup(global::Google.Cloud.Metastore.V1Alpha.DeleteBackupRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + } /// Client for DataprocMetastore @@ -659,6 +775,270 @@ protected DataprocMetastoreClient(ClientBaseConfiguration configuration) : base( { return CallInvoker.AsyncUnaryCall(__Method_UpdateMetadataImport, null, options, request); } + /// + /// Exports metadata from a service. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + public virtual global::Google.LongRunning.Operation ExportMetadata(global::Google.Cloud.Metastore.V1Alpha.ExportMetadataRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExportMetadata(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Exports metadata from a service. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + public virtual global::Google.LongRunning.Operation ExportMetadata(global::Google.Cloud.Metastore.V1Alpha.ExportMetadataRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ExportMetadata, null, options, request); + } + /// + /// Exports metadata from a service. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + public virtual grpc::AsyncUnaryCall ExportMetadataAsync(global::Google.Cloud.Metastore.V1Alpha.ExportMetadataRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExportMetadataAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Exports metadata from a service. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + public virtual grpc::AsyncUnaryCall ExportMetadataAsync(global::Google.Cloud.Metastore.V1Alpha.ExportMetadataRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ExportMetadata, null, options, request); + } + /// + /// Restores a service from a backup. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + public virtual global::Google.LongRunning.Operation RestoreService(global::Google.Cloud.Metastore.V1Alpha.RestoreServiceRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return RestoreService(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Restores a service from a backup. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + public virtual global::Google.LongRunning.Operation RestoreService(global::Google.Cloud.Metastore.V1Alpha.RestoreServiceRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_RestoreService, null, options, request); + } + /// + /// Restores a service from a backup. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + public virtual grpc::AsyncUnaryCall RestoreServiceAsync(global::Google.Cloud.Metastore.V1Alpha.RestoreServiceRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return RestoreServiceAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Restores a service from a backup. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + public virtual grpc::AsyncUnaryCall RestoreServiceAsync(global::Google.Cloud.Metastore.V1Alpha.RestoreServiceRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_RestoreService, null, options, request); + } + /// + /// Lists backups in a service. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + public virtual global::Google.Cloud.Metastore.V1Alpha.ListBackupsResponse ListBackups(global::Google.Cloud.Metastore.V1Alpha.ListBackupsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ListBackups(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Lists backups in a service. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + public virtual global::Google.Cloud.Metastore.V1Alpha.ListBackupsResponse ListBackups(global::Google.Cloud.Metastore.V1Alpha.ListBackupsRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ListBackups, null, options, request); + } + /// + /// Lists backups in a service. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + public virtual grpc::AsyncUnaryCall ListBackupsAsync(global::Google.Cloud.Metastore.V1Alpha.ListBackupsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ListBackupsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Lists backups in a service. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + public virtual grpc::AsyncUnaryCall ListBackupsAsync(global::Google.Cloud.Metastore.V1Alpha.ListBackupsRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ListBackups, null, options, request); + } + /// + /// Gets details of a single backup. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + public virtual global::Google.Cloud.Metastore.V1Alpha.Backup GetBackup(global::Google.Cloud.Metastore.V1Alpha.GetBackupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetBackup(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Gets details of a single backup. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + public virtual global::Google.Cloud.Metastore.V1Alpha.Backup GetBackup(global::Google.Cloud.Metastore.V1Alpha.GetBackupRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_GetBackup, null, options, request); + } + /// + /// Gets details of a single backup. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + public virtual grpc::AsyncUnaryCall GetBackupAsync(global::Google.Cloud.Metastore.V1Alpha.GetBackupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetBackupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Gets details of a single backup. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + public virtual grpc::AsyncUnaryCall GetBackupAsync(global::Google.Cloud.Metastore.V1Alpha.GetBackupRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_GetBackup, null, options, request); + } + /// + /// Creates a new Backup in a given project and location. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + public virtual global::Google.LongRunning.Operation CreateBackup(global::Google.Cloud.Metastore.V1Alpha.CreateBackupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return CreateBackup(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Creates a new Backup in a given project and location. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + public virtual global::Google.LongRunning.Operation CreateBackup(global::Google.Cloud.Metastore.V1Alpha.CreateBackupRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_CreateBackup, null, options, request); + } + /// + /// Creates a new Backup in a given project and location. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + public virtual grpc::AsyncUnaryCall CreateBackupAsync(global::Google.Cloud.Metastore.V1Alpha.CreateBackupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return CreateBackupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Creates a new Backup in a given project and location. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + public virtual grpc::AsyncUnaryCall CreateBackupAsync(global::Google.Cloud.Metastore.V1Alpha.CreateBackupRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_CreateBackup, null, options, request); + } + /// + /// Deletes a single backup. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + public virtual global::Google.LongRunning.Operation DeleteBackup(global::Google.Cloud.Metastore.V1Alpha.DeleteBackupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return DeleteBackup(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Deletes a single backup. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + public virtual global::Google.LongRunning.Operation DeleteBackup(global::Google.Cloud.Metastore.V1Alpha.DeleteBackupRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_DeleteBackup, null, options, request); + } + /// + /// Deletes a single backup. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + public virtual grpc::AsyncUnaryCall DeleteBackupAsync(global::Google.Cloud.Metastore.V1Alpha.DeleteBackupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return DeleteBackupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Deletes a single backup. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + public virtual grpc::AsyncUnaryCall DeleteBackupAsync(global::Google.Cloud.Metastore.V1Alpha.DeleteBackupRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_DeleteBackup, null, options, request); + } /// Creates a new instance of client from given ClientBaseConfiguration. protected override DataprocMetastoreClient NewInstance(ClientBaseConfiguration configuration) { @@ -679,7 +1059,13 @@ protected override DataprocMetastoreClient NewInstance(ClientBaseConfiguration c .AddMethod(__Method_ListMetadataImports, serviceImpl.ListMetadataImports) .AddMethod(__Method_GetMetadataImport, serviceImpl.GetMetadataImport) .AddMethod(__Method_CreateMetadataImport, serviceImpl.CreateMetadataImport) - .AddMethod(__Method_UpdateMetadataImport, serviceImpl.UpdateMetadataImport).Build(); + .AddMethod(__Method_UpdateMetadataImport, serviceImpl.UpdateMetadataImport) + .AddMethod(__Method_ExportMetadata, serviceImpl.ExportMetadata) + .AddMethod(__Method_RestoreService, serviceImpl.RestoreService) + .AddMethod(__Method_ListBackups, serviceImpl.ListBackups) + .AddMethod(__Method_GetBackup, serviceImpl.GetBackup) + .AddMethod(__Method_CreateBackup, serviceImpl.CreateBackup) + .AddMethod(__Method_DeleteBackup, serviceImpl.DeleteBackup).Build(); } /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. @@ -697,6 +1083,12 @@ public static void BindService(grpc::ServiceBinderBase serviceBinder, DataprocMe serviceBinder.AddMethod(__Method_GetMetadataImport, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetMetadataImport)); serviceBinder.AddMethod(__Method_CreateMetadataImport, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.CreateMetadataImport)); serviceBinder.AddMethod(__Method_UpdateMetadataImport, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.UpdateMetadataImport)); + serviceBinder.AddMethod(__Method_ExportMetadata, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ExportMetadata)); + serviceBinder.AddMethod(__Method_RestoreService, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.RestoreService)); + serviceBinder.AddMethod(__Method_ListBackups, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ListBackups)); + serviceBinder.AddMethod(__Method_GetBackup, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetBackup)); + serviceBinder.AddMethod(__Method_CreateBackup, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.CreateBackup)); + serviceBinder.AddMethod(__Method_DeleteBackup, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.DeleteBackup)); } } diff --git a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/MetastoreResourceNames.g.cs b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/MetastoreResourceNames.g.cs index 52cb57e7eff5..4b120db1344b 100644 --- a/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/MetastoreResourceNames.g.cs +++ b/apis/Google.Cloud.Metastore.V1Alpha/Google.Cloud.Metastore.V1Alpha/MetastoreResourceNames.g.cs @@ -511,6 +511,262 @@ public override string ToString() public static bool operator !=(MetadataImportName a, MetadataImportName b) => !(a == b); } + /// Resource name for the Backup resource. + public sealed partial class BackupName : gax::IResourceName, sys::IEquatable + { + /// The possible contents of . + public enum ResourceNameType + { + /// An unparsed resource name. + Unparsed = 0, + + /// + /// A resource name with pattern + /// projects/{project}/locations/{location}/services/{service}/backups/{backup}. + /// + ProjectLocationServiceBackup = 1, + } + + private static gax::PathTemplate s_projectLocationServiceBackup = new gax::PathTemplate("projects/{project}/locations/{location}/services/{service}/backups/{backup}"); + + /// Creates a containing an unparsed resource name. + /// The unparsed resource name. Must not be null. + /// + /// A new instance of containing the provided . + /// + public static BackupName FromUnparsed(gax::UnparsedResourceName unparsedResourceName) => + new BackupName(ResourceNameType.Unparsed, gax::GaxPreconditions.CheckNotNull(unparsedResourceName, nameof(unparsedResourceName))); + + /// + /// Creates a with the pattern + /// projects/{project}/locations/{location}/services/{service}/backups/{backup}. + /// + /// The Project ID. Must not be null or empty. + /// The Location ID. Must not be null or empty. + /// The Service ID. Must not be null or empty. + /// The Backup ID. Must not be null or empty. + /// A new instance of constructed from the provided ids. + public static BackupName FromProjectLocationServiceBackup(string projectId, string locationId, string serviceId, string backupId) => + new BackupName(ResourceNameType.ProjectLocationServiceBackup, projectId: gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), locationId: gax::GaxPreconditions.CheckNotNullOrEmpty(locationId, nameof(locationId)), serviceId: gax::GaxPreconditions.CheckNotNullOrEmpty(serviceId, nameof(serviceId)), backupId: gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId))); + + /// + /// Formats the IDs into the string representation of this with pattern + /// projects/{project}/locations/{location}/services/{service}/backups/{backup}. + /// + /// The Project ID. Must not be null or empty. + /// The Location ID. Must not be null or empty. + /// The Service ID. Must not be null or empty. + /// The Backup ID. Must not be null or empty. + /// + /// The string representation of this with pattern + /// projects/{project}/locations/{location}/services/{service}/backups/{backup}. + /// + public static string Format(string projectId, string locationId, string serviceId, string backupId) => + FormatProjectLocationServiceBackup(projectId, locationId, serviceId, backupId); + + /// + /// Formats the IDs into the string representation of this with pattern + /// projects/{project}/locations/{location}/services/{service}/backups/{backup}. + /// + /// The Project ID. Must not be null or empty. + /// The Location ID. Must not be null or empty. + /// The Service ID. Must not be null or empty. + /// The Backup ID. Must not be null or empty. + /// + /// The string representation of this with pattern + /// projects/{project}/locations/{location}/services/{service}/backups/{backup}. + /// + public static string FormatProjectLocationServiceBackup(string projectId, string locationId, string serviceId, string backupId) => + s_projectLocationServiceBackup.Expand(gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), gax::GaxPreconditions.CheckNotNullOrEmpty(locationId, nameof(locationId)), gax::GaxPreconditions.CheckNotNullOrEmpty(serviceId, nameof(serviceId)), gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId))); + + /// Parses the given resource name string into a new instance. + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// + /// + /// projects/{project}/locations/{location}/services/{service}/backups/{backup} + /// + /// + /// + /// + /// The resource name in string form. Must not be null. + /// The parsed if successful. + public static BackupName Parse(string backupName) => Parse(backupName, false); + + /// + /// Parses the given resource name string into a new instance; optionally allowing an + /// unparseable resource name. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// + /// + /// projects/{project}/locations/{location}/services/{service}/backups/{backup} + /// + /// + /// + /// Or may be in any format if is true. + /// + /// The resource name in string form. Must not be null. + /// + /// If true will successfully store an unparseable resource name into the + /// property; otherwise will throw an if an unparseable resource name is + /// specified. + /// + /// The parsed if successful. + public static BackupName Parse(string backupName, bool allowUnparsed) => + TryParse(backupName, allowUnparsed, out BackupName result) ? result : throw new sys::ArgumentException("The given resource-name matches no pattern."); + + /// + /// Tries to parse the given resource name string into a new instance. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// + /// + /// projects/{project}/locations/{location}/services/{service}/backups/{backup} + /// + /// + /// + /// + /// The resource name in string form. Must not be null. + /// + /// When this method returns, the parsed , or null if parsing failed. + /// + /// true if the name was parsed successfully; false otherwise. + public static bool TryParse(string backupName, out BackupName result) => TryParse(backupName, false, out result); + + /// + /// Tries to parse the given resource name string into a new instance; optionally + /// allowing an unparseable resource name. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// + /// + /// projects/{project}/locations/{location}/services/{service}/backups/{backup} + /// + /// + /// + /// Or may be in any format if is true. + /// + /// The resource name in string form. Must not be null. + /// + /// If true will successfully store an unparseable resource name into the + /// property; otherwise will throw an if an unparseable resource name is + /// specified. + /// + /// + /// When this method returns, the parsed , or null if parsing failed. + /// + /// true if the name was parsed successfully; false otherwise. + public static bool TryParse(string backupName, bool allowUnparsed, out BackupName result) + { + gax::GaxPreconditions.CheckNotNull(backupName, nameof(backupName)); + gax::TemplatedResourceName resourceName; + if (s_projectLocationServiceBackup.TryParseName(backupName, out resourceName)) + { + result = FromProjectLocationServiceBackup(resourceName[0], resourceName[1], resourceName[2], resourceName[3]); + return true; + } + if (allowUnparsed) + { + if (gax::UnparsedResourceName.TryParse(backupName, out gax::UnparsedResourceName unparsedResourceName)) + { + result = FromUnparsed(unparsedResourceName); + return true; + } + } + result = null; + return false; + } + + private BackupName(ResourceNameType type, gax::UnparsedResourceName unparsedResourceName = null, string backupId = null, string locationId = null, string projectId = null, string serviceId = null) + { + Type = type; + UnparsedResource = unparsedResourceName; + BackupId = backupId; + LocationId = locationId; + ProjectId = projectId; + ServiceId = serviceId; + } + + /// + /// Constructs a new instance of a class from the component parts of pattern + /// projects/{project}/locations/{location}/services/{service}/backups/{backup} + /// + /// The Project ID. Must not be null or empty. + /// The Location ID. Must not be null or empty. + /// The Service ID. Must not be null or empty. + /// The Backup ID. Must not be null or empty. + public BackupName(string projectId, string locationId, string serviceId, string backupId) : this(ResourceNameType.ProjectLocationServiceBackup, projectId: gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), locationId: gax::GaxPreconditions.CheckNotNullOrEmpty(locationId, nameof(locationId)), serviceId: gax::GaxPreconditions.CheckNotNullOrEmpty(serviceId, nameof(serviceId)), backupId: gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId))) + { + } + + /// The of the contained resource name. + public ResourceNameType Type { get; } + + /// + /// The contained . Only non-null if this instance contains an + /// unparsed resource name. + /// + public gax::UnparsedResourceName UnparsedResource { get; } + + /// + /// The Backup ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string BackupId { get; } + + /// + /// The Location ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string LocationId { get; } + + /// + /// The Project ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string ProjectId { get; } + + /// + /// The Service ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string ServiceId { get; } + + /// Whether this instance contains a resource name with a known pattern. + public bool IsKnownPattern => Type != ResourceNameType.Unparsed; + + /// The string representation of the resource name. + /// The string representation of the resource name. + public override string ToString() + { + switch (Type) + { + case ResourceNameType.Unparsed: return UnparsedResource.ToString(); + case ResourceNameType.ProjectLocationServiceBackup: return s_projectLocationServiceBackup.Expand(ProjectId, LocationId, ServiceId, BackupId); + default: throw new sys::InvalidOperationException("Unrecognized resource-type."); + } + } + + /// Returns a hash code for this resource name. + public override int GetHashCode() => ToString().GetHashCode(); + + /// + public override bool Equals(object obj) => Equals(obj as BackupName); + + /// + public bool Equals(BackupName other) => ToString() == other?.ToString(); + + /// + public static bool operator ==(BackupName a, BackupName b) => ReferenceEquals(a, b) || (a?.Equals(b) ?? false); + + /// + public static bool operator !=(BackupName a, BackupName b) => !(a == b); + } + /// Resource name for the Network resource. public sealed partial class NetworkName : gax::IResourceName, sys::IEquatable { @@ -759,6 +1015,28 @@ public partial class MetadataImport } } + public partial class Backup + { + /// + /// -typed view over the resource name property. + /// + public gcmv::BackupName BackupName + { + get => string.IsNullOrEmpty(Name) ? null : gcmv::BackupName.Parse(Name, allowUnparsed: true); + set => Name = value?.ToString() ?? ""; + } + } + + public partial class Restore + { + /// -typed view over the resource name property. + public BackupName BackupAsBackupName + { + get => string.IsNullOrEmpty(Backup) ? null : BackupName.Parse(Backup, allowUnparsed: true); + set => Backup = value?.ToString() ?? ""; + } + } + public partial class ListServicesRequest { /// @@ -842,4 +1120,83 @@ public ServiceName ParentAsServiceName set => Parent = value?.ToString() ?? ""; } } + + public partial class ListBackupsRequest + { + /// + /// -typed view over the resource name property. + /// + public ServiceName ParentAsServiceName + { + get => string.IsNullOrEmpty(Parent) ? null : ServiceName.Parse(Parent, allowUnparsed: true); + set => Parent = value?.ToString() ?? ""; + } + } + + public partial class GetBackupRequest + { + /// + /// -typed view over the resource name property. + /// + public gcmv::BackupName BackupName + { + get => string.IsNullOrEmpty(Name) ? null : gcmv::BackupName.Parse(Name, allowUnparsed: true); + set => Name = value?.ToString() ?? ""; + } + } + + public partial class CreateBackupRequest + { + /// + /// -typed view over the resource name property. + /// + public ServiceName ParentAsServiceName + { + get => string.IsNullOrEmpty(Parent) ? null : ServiceName.Parse(Parent, allowUnparsed: true); + set => Parent = value?.ToString() ?? ""; + } + } + + public partial class DeleteBackupRequest + { + /// + /// -typed view over the resource name property. + /// + public gcmv::BackupName BackupName + { + get => string.IsNullOrEmpty(Name) ? null : gcmv::BackupName.Parse(Name, allowUnparsed: true); + set => Name = value?.ToString() ?? ""; + } + } + + public partial class ExportMetadataRequest + { + /// + /// -typed view over the resource name property. + /// + public ServiceName ServiceAsServiceName + { + get => string.IsNullOrEmpty(Service) ? null : ServiceName.Parse(Service, allowUnparsed: true); + set => Service = value?.ToString() ?? ""; + } + } + + public partial class RestoreServiceRequest + { + /// + /// -typed view over the resource name property. + /// + public ServiceName ServiceAsServiceName + { + get => string.IsNullOrEmpty(Service) ? null : ServiceName.Parse(Service, allowUnparsed: true); + set => Service = value?.ToString() ?? ""; + } + + /// -typed view over the resource name property. + public BackupName BackupAsBackupName + { + get => string.IsNullOrEmpty(Backup) ? null : BackupName.Parse(Backup, allowUnparsed: true); + set => Backup = value?.ToString() ?? ""; + } + } } diff --git a/apis/Google.Cloud.Metastore.V1Alpha/synth.metadata b/apis/Google.Cloud.Metastore.V1Alpha/synth.metadata index d8903efa6500..6d968c9a49f1 100644 --- a/apis/Google.Cloud.Metastore.V1Alpha/synth.metadata +++ b/apis/Google.Cloud.Metastore.V1Alpha/synth.metadata @@ -4,7 +4,7 @@ "git": { "name": "googleapis", "remote": "https://github.com/googleapis/googleapis.git", - "sha": "ee4bac5de3e4bfc4bbca87a6b256f1a58dcfadd0" + "sha": "8f117308d5bb55816953a0d6ad1a7d27a69a7d3f" } } ]