diff --git a/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2.Snippets/BigtableTableAdminClientSnippets.g.cs b/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2.Snippets/BigtableTableAdminClientSnippets.g.cs index 24745307430e..1491609a7ba0 100644 --- a/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2.Snippets/BigtableTableAdminClientSnippets.g.cs +++ b/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2.Snippets/BigtableTableAdminClientSnippets.g.cs @@ -1836,6 +1836,132 @@ public async Task CreateBackupRequestObjectAsync() // End snippet } + /// Snippet for CreateBackup + public void CreateBackup() + { + // Snippet: CreateBackup(string, string, Backup, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/instances/[INSTANCE]/clusters/[CLUSTER]"; + string backupId = ""; + Backup backup = new Backup(); + // Make the request + Operation response = bigtableTableAdminClient.CreateBackup(parent, backupId, backup); + + // 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 = bigtableTableAdminClient.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, string, Backup, CallSettings) + // Additional: CreateBackupAsync(string, string, Backup, CancellationToken) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/instances/[INSTANCE]/clusters/[CLUSTER]"; + string backupId = ""; + Backup backup = new Backup(); + // Make the request + Operation response = await bigtableTableAdminClient.CreateBackupAsync(parent, backupId, backup); + + // 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 bigtableTableAdminClient.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(ClusterName, string, Backup, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + ClusterName parent = ClusterName.FromProjectInstanceCluster("[PROJECT]", "[INSTANCE]", "[CLUSTER]"); + string backupId = ""; + Backup backup = new Backup(); + // Make the request + Operation response = bigtableTableAdminClient.CreateBackup(parent, backupId, backup); + + // 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 = bigtableTableAdminClient.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(ClusterName, string, Backup, CallSettings) + // Additional: CreateBackupAsync(ClusterName, string, Backup, CancellationToken) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + ClusterName parent = ClusterName.FromProjectInstanceCluster("[PROJECT]", "[INSTANCE]", "[CLUSTER]"); + string backupId = ""; + Backup backup = new Backup(); + // Make the request + Operation response = await bigtableTableAdminClient.CreateBackupAsync(parent, backupId, backup); + + // 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 bigtableTableAdminClient.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 GetBackup public void GetBackupRequestObject() { @@ -1869,6 +1995,60 @@ public async Task GetBackupRequestObjectAsync() // End snippet } + /// Snippet for GetBackup + public void GetBackup() + { + // Snippet: GetBackup(string, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/instances/[INSTANCE]/clusters/[CLUSTER]/backups/[BACKUP]"; + // Make the request + Backup response = bigtableTableAdminClient.GetBackup(name); + // End snippet + } + + /// Snippet for GetBackupAsync + public async Task GetBackupAsync() + { + // Snippet: GetBackupAsync(string, CallSettings) + // Additional: GetBackupAsync(string, CancellationToken) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/instances/[INSTANCE]/clusters/[CLUSTER]/backups/[BACKUP]"; + // Make the request + Backup response = await bigtableTableAdminClient.GetBackupAsync(name); + // End snippet + } + + /// Snippet for GetBackup + public void GetBackupResourceNames() + { + // Snippet: GetBackup(BackupName, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + BackupName name = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"); + // Make the request + Backup response = bigtableTableAdminClient.GetBackup(name); + // End snippet + } + + /// Snippet for GetBackupAsync + public async Task GetBackupResourceNamesAsync() + { + // Snippet: GetBackupAsync(BackupName, CallSettings) + // Additional: GetBackupAsync(BackupName, CancellationToken) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + BackupName name = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"); + // Make the request + Backup response = await bigtableTableAdminClient.GetBackupAsync(name); + // End snippet + } + /// Snippet for UpdateBackup public void UpdateBackupRequestObject() { @@ -1904,6 +2084,35 @@ public async Task UpdateBackupRequestObjectAsync() // End snippet } + /// Snippet for UpdateBackup + public void UpdateBackup() + { + // Snippet: UpdateBackup(Backup, FieldMask, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + Backup backup = new Backup(); + FieldMask updateMask = new FieldMask(); + // Make the request + Backup response = bigtableTableAdminClient.UpdateBackup(backup, updateMask); + // End snippet + } + + /// Snippet for UpdateBackupAsync + public async Task UpdateBackupAsync() + { + // Snippet: UpdateBackupAsync(Backup, FieldMask, CallSettings) + // Additional: UpdateBackupAsync(Backup, FieldMask, CancellationToken) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + Backup backup = new Backup(); + FieldMask updateMask = new FieldMask(); + // Make the request + Backup response = await bigtableTableAdminClient.UpdateBackupAsync(backup, updateMask); + // End snippet + } + /// Snippet for DeleteBackup public void DeleteBackupRequestObject() { @@ -1937,6 +2146,60 @@ public async Task DeleteBackupRequestObjectAsync() // End snippet } + /// Snippet for DeleteBackup + public void DeleteBackup() + { + // Snippet: DeleteBackup(string, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/instances/[INSTANCE]/clusters/[CLUSTER]/backups/[BACKUP]"; + // Make the request + bigtableTableAdminClient.DeleteBackup(name); + // End snippet + } + + /// Snippet for DeleteBackupAsync + public async Task DeleteBackupAsync() + { + // Snippet: DeleteBackupAsync(string, CallSettings) + // Additional: DeleteBackupAsync(string, CancellationToken) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/instances/[INSTANCE]/clusters/[CLUSTER]/backups/[BACKUP]"; + // Make the request + await bigtableTableAdminClient.DeleteBackupAsync(name); + // End snippet + } + + /// Snippet for DeleteBackup + public void DeleteBackupResourceNames() + { + // Snippet: DeleteBackup(BackupName, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + BackupName name = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"); + // Make the request + bigtableTableAdminClient.DeleteBackup(name); + // End snippet + } + + /// Snippet for DeleteBackupAsync + public async Task DeleteBackupResourceNamesAsync() + { + // Snippet: DeleteBackupAsync(BackupName, CallSettings) + // Additional: DeleteBackupAsync(BackupName, CancellationToken) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + BackupName name = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"); + // Make the request + await bigtableTableAdminClient.DeleteBackupAsync(name); + // End snippet + } + /// Snippet for ListBackups public void ListBackupsRequestObject() { @@ -2037,6 +2300,186 @@ await response.AsRawResponses().ForEachAsync((ListBackupsResponse page) => // End snippet } + /// Snippet for ListBackups + public void ListBackups() + { + // Snippet: ListBackups(string, string, int?, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/instances/[INSTANCE]/clusters/[CLUSTER]"; + // Make the request + PagedEnumerable response = bigtableTableAdminClient.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 + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/instances/[INSTANCE]/clusters/[CLUSTER]"; + // Make the request + PagedAsyncEnumerable response = bigtableTableAdminClient.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(ClusterName, string, int?, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); + // Initialize request argument(s) + ClusterName parent = ClusterName.FromProjectInstanceCluster("[PROJECT]", "[INSTANCE]", "[CLUSTER]"); + // Make the request + PagedEnumerable response = bigtableTableAdminClient.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(ClusterName, string, int?, CallSettings) + // Create client + BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); + // Initialize request argument(s) + ClusterName parent = ClusterName.FromProjectInstanceCluster("[PROJECT]", "[INSTANCE]", "[CLUSTER]"); + // Make the request + PagedAsyncEnumerable response = bigtableTableAdminClient.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 RestoreTable public void RestoreTableRequestObject() { diff --git a/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2.Tests/BigtableTableAdminClientTest.g.cs b/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2.Tests/BigtableTableAdminClientTest.g.cs index 6c03a6be7b8e..90bc51acdf01 100644 --- a/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2.Tests/BigtableTableAdminClientTest.g.cs +++ b/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2.Tests/BigtableTableAdminClientTest.g.cs @@ -1435,6 +1435,114 @@ public void GetBackupRequestObject() 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.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + SourceTable = "source_table3c9665d0", + ExpireTime = new wkt::Timestamp(), + StartTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + SizeBytes = 4628423819757039038L, + State = Backup.Types.State.Unspecified, + }; + mockGrpcClient.Setup(x => x.GetBackup(request, moq::It.IsAny())).Returns(expectedResponse); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(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.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + SourceTable = "source_table3c9665d0", + ExpireTime = new wkt::Timestamp(), + StartTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + SizeBytes = 4628423819757039038L, + State = Backup.Types.State.Unspecified, + }; + mockGrpcClient.Setup(x => x.GetBackupAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(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.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + SourceTable = "source_table3c9665d0", + ExpireTime = new wkt::Timestamp(), + StartTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + SizeBytes = 4628423819757039038L, + State = Backup.Types.State.Unspecified, + }; + mockGrpcClient.Setup(x => x.GetBackup(request, moq::It.IsAny())).Returns(expectedResponse); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(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.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + SourceTable = "source_table3c9665d0", + ExpireTime = new wkt::Timestamp(), + StartTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + SizeBytes = 4628423819757039038L, + State = Backup.Types.State.Unspecified, + }; + mockGrpcClient.Setup(x => x.GetBackupAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(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(); + } + [xunit::FactAttribute] public void UpdateBackupRequestObject() { @@ -1491,6 +1599,62 @@ public void UpdateBackupRequestObject() mockGrpcClient.VerifyAll(); } + [xunit::FactAttribute] + public void UpdateBackup() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + UpdateBackupRequest request = new UpdateBackupRequest + { + Backup = new Backup(), + UpdateMask = new wkt::FieldMask(), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + SourceTable = "source_table3c9665d0", + ExpireTime = new wkt::Timestamp(), + StartTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + SizeBytes = 4628423819757039038L, + State = Backup.Types.State.Unspecified, + }; + mockGrpcClient.Setup(x => x.UpdateBackup(request, moq::It.IsAny())).Returns(expectedResponse); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(mockGrpcClient.Object, null); + Backup response = client.UpdateBackup(request.Backup, request.UpdateMask); + xunit::Assert.Same(expectedResponse, response); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public async stt::Task UpdateBackupAsync() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + UpdateBackupRequest request = new UpdateBackupRequest + { + Backup = new Backup(), + UpdateMask = new wkt::FieldMask(), + }; + Backup expectedResponse = new Backup + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + SourceTable = "source_table3c9665d0", + ExpireTime = new wkt::Timestamp(), + StartTime = new wkt::Timestamp(), + EndTime = new wkt::Timestamp(), + SizeBytes = 4628423819757039038L, + State = Backup.Types.State.Unspecified, + }; + mockGrpcClient.Setup(x => x.UpdateBackupAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(mockGrpcClient.Object, null); + Backup responseCallSettings = await client.UpdateBackupAsync(request.Backup, request.UpdateMask, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); + xunit::Assert.Same(expectedResponse, responseCallSettings); + Backup responseCancellationToken = await client.UpdateBackupAsync(request.Backup, request.UpdateMask, st::CancellationToken.None); + xunit::Assert.Same(expectedResponse, responseCancellationToken); + mockGrpcClient.VerifyAll(); + } + [xunit::FactAttribute] public void DeleteBackupRequestObject() { @@ -1524,6 +1688,72 @@ public void DeleteBackupRequestObject() mockGrpcClient.VerifyAll(); } + [xunit::FactAttribute] + public void DeleteBackup() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + DeleteBackupRequest request = new DeleteBackupRequest + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + }; + wkt::Empty expectedResponse = new wkt::Empty { }; + mockGrpcClient.Setup(x => x.DeleteBackup(request, moq::It.IsAny())).Returns(expectedResponse); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(mockGrpcClient.Object, null); + client.DeleteBackup(request.Name); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public async stt::Task DeleteBackupAsync() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + DeleteBackupRequest request = new DeleteBackupRequest + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + }; + wkt::Empty expectedResponse = new wkt::Empty { }; + mockGrpcClient.Setup(x => x.DeleteBackupAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(mockGrpcClient.Object, null); + await client.DeleteBackupAsync(request.Name, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); + await client.DeleteBackupAsync(request.Name, st::CancellationToken.None); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public void DeleteBackupResourceNames() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + DeleteBackupRequest request = new DeleteBackupRequest + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + }; + wkt::Empty expectedResponse = new wkt::Empty { }; + mockGrpcClient.Setup(x => x.DeleteBackup(request, moq::It.IsAny())).Returns(expectedResponse); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(mockGrpcClient.Object, null); + client.DeleteBackup(request.BackupName); + mockGrpcClient.VerifyAll(); + } + + [xunit::FactAttribute] + public async stt::Task DeleteBackupResourceNamesAsync() + { + moq::Mock mockGrpcClient = new moq::Mock(moq::MockBehavior.Strict); + mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock().Object); + DeleteBackupRequest request = new DeleteBackupRequest + { + BackupName = BackupName.FromProjectInstanceClusterBackup("[PROJECT]", "[INSTANCE]", "[CLUSTER]", "[BACKUP]"), + }; + wkt::Empty expectedResponse = new wkt::Empty { }; + mockGrpcClient.Setup(x => x.DeleteBackupAsync(request, moq::It.IsAny())).Returns(new grpccore::AsyncUnaryCall(stt::Task.FromResult(expectedResponse), null, null, null, null)); + BigtableTableAdminClient client = new BigtableTableAdminClientImpl(mockGrpcClient.Object, null); + await client.DeleteBackupAsync(request.BackupName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); + await client.DeleteBackupAsync(request.BackupName, st::CancellationToken.None); + mockGrpcClient.VerifyAll(); + } + [xunit::FactAttribute] public void GetIamPolicyRequestObject() { diff --git a/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2/BigtableTableAdmin.cs b/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2/BigtableTableAdmin.cs index ad74b6e5a6ea..7c130aa28dc2 100644 --- a/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2/BigtableTableAdmin.cs +++ b/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2/BigtableTableAdmin.cs @@ -125,7 +125,7 @@ static BigtableTableAdminReflection() { "YmxlLmFkbWluLnYyLk9wZXJhdGlvblByb2dyZXNzQg0KC3NvdXJjZV9pbmZv", "ImwKHU9wdGltaXplUmVzdG9yZWRUYWJsZU1ldGFkYXRhEgwKBG5hbWUYASAB", "KAkSPQoIcHJvZ3Jlc3MYAiABKAsyKy5nb29nbGUuYmlndGFibGUuYWRtaW4u", - "djIuT3BlcmF0aW9uUHJvZ3Jlc3MygSQKEkJpZ3RhYmxlVGFibGVBZG1pbhKr", + "djIuT3BlcmF0aW9uUHJvZ3Jlc3MyyCQKEkJpZ3RhYmxlVGFibGVBZG1pbhKr", "AQoLQ3JlYXRlVGFibGUSLC5nb29nbGUuYmlndGFibGUuYWRtaW4udjIuQ3Jl", "YXRlVGFibGVSZXF1ZXN0Gh8uZ29vZ2xlLmJpZ3RhYmxlLmFkbWluLnYyLlRh", "YmxlIk2C0+STAi8iKi92Mi97cGFyZW50PXByb2plY3RzLyovaW5zdGFuY2Vz", @@ -181,58 +181,59 @@ static BigtableTableAdminReflection() { "Ei8uZ29vZ2xlLmJpZ3RhYmxlLmFkbWluLnYyLkRlbGV0ZVNuYXBzaG90UmVx", "dWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSJHgtPkkwI6KjgvdjIve25h", "bWU9cHJvamVjdHMvKi9pbnN0YW5jZXMvKi9jbHVzdGVycy8qL3NuYXBzaG90", - "cy8qfdpBBG5hbWUSxQEKDENyZWF0ZUJhY2t1cBItLmdvb2dsZS5iaWd0YWJs", + "cy8qfdpBBG5hbWUS4AEKDENyZWF0ZUJhY2t1cBItLmdvb2dsZS5iaWd0YWJs", "ZS5hZG1pbi52Mi5DcmVhdGVCYWNrdXBSZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdy", - "dW5uaW5nLk9wZXJhdGlvbiJngtPkkwJAIjYvdjIve3BhcmVudD1wcm9qZWN0", - "cy8qL2luc3RhbmNlcy8qL2NsdXN0ZXJzLyp9L2JhY2t1cHM6BmJhY2t1cMpB", - "HgoGQmFja3VwEhRDcmVhdGVCYWNrdXBNZXRhZGF0YRKZAQoJR2V0QmFja3Vw", - "EiouZ29vZ2xlLmJpZ3RhYmxlLmFkbWluLnYyLkdldEJhY2t1cFJlcXVlc3Qa", - "IC5nb29nbGUuYmlndGFibGUuYWRtaW4udjIuQmFja3VwIj6C0+STAjgSNi92", - "Mi97bmFtZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2NsdXN0ZXJzLyovYmFj", - "a3Vwcy8qfRKuAQoMVXBkYXRlQmFja3VwEi0uZ29vZ2xlLmJpZ3RhYmxlLmFk", - "bWluLnYyLlVwZGF0ZUJhY2t1cFJlcXVlc3QaIC5nb29nbGUuYmlndGFibGUu", - "YWRtaW4udjIuQmFja3VwIk2C0+STAkcyPS92Mi97YmFja3VwLm5hbWU9cHJv", - "amVjdHMvKi9pbnN0YW5jZXMvKi9jbHVzdGVycy8qL2JhY2t1cHMvKn06BmJh", - "Y2t1cBKVAQoMRGVsZXRlQmFja3VwEi0uZ29vZ2xlLmJpZ3RhYmxlLmFkbWlu", - "LnYyLkRlbGV0ZUJhY2t1cFJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1w", - "dHkiPoLT5JMCOCo2L3YyL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyov", - "Y2x1c3RlcnMvKi9iYWNrdXBzLyp9EqoBCgtMaXN0QmFja3VwcxIsLmdvb2ds", - "ZS5iaWd0YWJsZS5hZG1pbi52Mi5MaXN0QmFja3Vwc1JlcXVlc3QaLS5nb29n", - "bGUuYmlndGFibGUuYWRtaW4udjIuTGlzdEJhY2t1cHNSZXNwb25zZSI+gtPk", - "kwI4EjYvdjIve3BhcmVudD1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2NsdXN0", - "ZXJzLyp9L2JhY2t1cHMSuwEKDFJlc3RvcmVUYWJsZRItLmdvb2dsZS5iaWd0", - "YWJsZS5hZG1pbi52Mi5SZXN0b3JlVGFibGVSZXF1ZXN0Gh0uZ29vZ2xlLmxv", - "bmdydW5uaW5nLk9wZXJhdGlvbiJdgtPkkwI3IjIvdjIve3BhcmVudD1wcm9q", - "ZWN0cy8qL2luc3RhbmNlcy8qfS90YWJsZXM6cmVzdG9yZToBKspBHQoFVGFi", - "bGUSFFJlc3RvcmVUYWJsZU1ldGFkYXRhEpwBCgxHZXRJYW1Qb2xpY3kSIi5n", - "b29nbGUuaWFtLnYxLkdldElhbVBvbGljeVJlcXVlc3QaFS5nb29nbGUuaWFt", - "LnYxLlBvbGljeSJRgtPkkwJAIjsvdjIve3Jlc291cmNlPXByb2plY3RzLyov", - "aW5zdGFuY2VzLyovdGFibGVzLyp9OmdldElhbVBvbGljeToBKtpBCHJlc291", - "cmNlEvMBCgxTZXRJYW1Qb2xpY3kSIi5nb29nbGUuaWFtLnYxLlNldElhbVBv", - "bGljeVJlcXVlc3QaFS5nb29nbGUuaWFtLnYxLlBvbGljeSKnAYLT5JMCjgEi", + "dW5uaW5nLk9wZXJhdGlvbiKBAYLT5JMCQCI2L3YyL3twYXJlbnQ9cHJvamVj", + "dHMvKi9pbnN0YW5jZXMvKi9jbHVzdGVycy8qfS9iYWNrdXBzOgZiYWNrdXDK", + "QR4KBkJhY2t1cBIUQ3JlYXRlQmFja3VwTWV0YWRhdGHaQRdwYXJlbnQsYmFj", + "a3VwX2lkLGJhY2t1cBKgAQoJR2V0QmFja3VwEiouZ29vZ2xlLmJpZ3RhYmxl", + "LmFkbWluLnYyLkdldEJhY2t1cFJlcXVlc3QaIC5nb29nbGUuYmlndGFibGUu", + "YWRtaW4udjIuQmFja3VwIkWC0+STAjgSNi92Mi97bmFtZT1wcm9qZWN0cy8q", + "L2luc3RhbmNlcy8qL2NsdXN0ZXJzLyovYmFja3Vwcy8qfdpBBG5hbWUSwwEK", + "DFVwZGF0ZUJhY2t1cBItLmdvb2dsZS5iaWd0YWJsZS5hZG1pbi52Mi5VcGRh", + "dGVCYWNrdXBSZXF1ZXN0GiAuZ29vZ2xlLmJpZ3RhYmxlLmFkbWluLnYyLkJh", + "Y2t1cCJigtPkkwJHMj0vdjIve2JhY2t1cC5uYW1lPXByb2plY3RzLyovaW5z", + "dGFuY2VzLyovY2x1c3RlcnMvKi9iYWNrdXBzLyp9OgZiYWNrdXDaQRJiYWNr", + "dXAsdXBkYXRlX21hc2sSnAEKDERlbGV0ZUJhY2t1cBItLmdvb2dsZS5iaWd0", + "YWJsZS5hZG1pbi52Mi5EZWxldGVCYWNrdXBSZXF1ZXN0GhYuZ29vZ2xlLnBy", + "b3RvYnVmLkVtcHR5IkWC0+STAjgqNi92Mi97bmFtZT1wcm9qZWN0cy8qL2lu", + "c3RhbmNlcy8qL2NsdXN0ZXJzLyovYmFja3Vwcy8qfdpBBG5hbWUSswEKC0xp", + "c3RCYWNrdXBzEiwuZ29vZ2xlLmJpZ3RhYmxlLmFkbWluLnYyLkxpc3RCYWNr", + "dXBzUmVxdWVzdBotLmdvb2dsZS5iaWd0YWJsZS5hZG1pbi52Mi5MaXN0QmFj", + "a3Vwc1Jlc3BvbnNlIkeC0+STAjgSNi92Mi97cGFyZW50PXByb2plY3RzLyov", + "aW5zdGFuY2VzLyovY2x1c3RlcnMvKn0vYmFja3Vwc9pBBnBhcmVudBK7AQoM", + "UmVzdG9yZVRhYmxlEi0uZ29vZ2xlLmJpZ3RhYmxlLmFkbWluLnYyLlJlc3Rv", + "cmVUYWJsZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9u", + "Il2C0+STAjciMi92Mi97cGFyZW50PXByb2plY3RzLyovaW5zdGFuY2VzLyp9", + "L3RhYmxlczpyZXN0b3JlOgEqykEdCgVUYWJsZRIUUmVzdG9yZVRhYmxlTWV0", + "YWRhdGESnAEKDEdldElhbVBvbGljeRIiLmdvb2dsZS5pYW0udjEuR2V0SWFt", + "UG9saWN5UmVxdWVzdBoVLmdvb2dsZS5pYW0udjEuUG9saWN5IlGC0+STAkAi", "Oy92Mi97cmVzb3VyY2U9cHJvamVjdHMvKi9pbnN0YW5jZXMvKi90YWJsZXMv", - "Kn06c2V0SWFtUG9saWN5OgEqWkwiRy92Mi97cmVzb3VyY2U9cHJvamVjdHMv", - "Ki9pbnN0YW5jZXMvKi9jbHVzdGVycy8qL2JhY2t1cHMvKn06c2V0SWFtUG9s", - "aWN5OgEq2kEPcmVzb3VyY2UscG9saWN5EqQCChJUZXN0SWFtUGVybWlzc2lv", - "bnMSKC5nb29nbGUuaWFtLnYxLlRlc3RJYW1QZXJtaXNzaW9uc1JlcXVlc3Qa", - "KS5nb29nbGUuaWFtLnYxLlRlc3RJYW1QZXJtaXNzaW9uc1Jlc3BvbnNlIrgB", - "gtPkkwKaASJBL3YyL3tyZXNvdXJjZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8q", - "L3RhYmxlcy8qfTp0ZXN0SWFtUGVybWlzc2lvbnM6ASpaUiJNL3YyL3tyZXNv", - "dXJjZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2NsdXN0ZXJzLyovYmFja3Vw", - "cy8qfTp0ZXN0SWFtUGVybWlzc2lvbnM6ASraQRRyZXNvdXJjZSxwZXJtaXNz", - "aW9ucxreAspBHGJpZ3RhYmxlYWRtaW4uZ29vZ2xlYXBpcy5jb23SQbsCaHR0", - "cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9iaWd0YWJsZS5hZG1pbixo", - "dHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2JpZ3RhYmxlLmFkbWlu", - "LnRhYmxlLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2xvdWQt", - "YmlndGFibGUuYWRtaW4saHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0", - "aC9jbG91ZC1iaWd0YWJsZS5hZG1pbi50YWJsZSxodHRwczovL3d3dy5nb29n", - "bGVhcGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtLGh0dHBzOi8vd3d3Lmdv", - "b2dsZWFwaXMuY29tL2F1dGgvY2xvdWQtcGxhdGZvcm0ucmVhZC1vbmx5QroB", - "Chxjb20uZ29vZ2xlLmJpZ3RhYmxlLmFkbWluLnYyQhdCaWd0YWJsZVRhYmxl", - "QWRtaW5Qcm90b1ABWj1nb29nbGUuZ29sYW5nLm9yZy9nZW5wcm90by9nb29n", - "bGVhcGlzL2JpZ3RhYmxlL2FkbWluL3YyO2FkbWluqgIeR29vZ2xlLkNsb3Vk", - "LkJpZ3RhYmxlLkFkbWluLlYyygIeR29vZ2xlXENsb3VkXEJpZ3RhYmxlXEFk", - "bWluXFYyYgZwcm90bzM=")); + "Kn06Z2V0SWFtUG9saWN5OgEq2kEIcmVzb3VyY2US8wEKDFNldElhbVBvbGlj", + "eRIiLmdvb2dsZS5pYW0udjEuU2V0SWFtUG9saWN5UmVxdWVzdBoVLmdvb2ds", + "ZS5pYW0udjEuUG9saWN5IqcBgtPkkwKOASI7L3YyL3tyZXNvdXJjZT1wcm9q", + "ZWN0cy8qL2luc3RhbmNlcy8qL3RhYmxlcy8qfTpzZXRJYW1Qb2xpY3k6ASpa", + "TCJHL3YyL3tyZXNvdXJjZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2NsdXN0", + "ZXJzLyovYmFja3Vwcy8qfTpzZXRJYW1Qb2xpY3k6ASraQQ9yZXNvdXJjZSxw", + "b2xpY3kSpAIKElRlc3RJYW1QZXJtaXNzaW9ucxIoLmdvb2dsZS5pYW0udjEu", + "VGVzdElhbVBlcm1pc3Npb25zUmVxdWVzdBopLmdvb2dsZS5pYW0udjEuVGVz", + "dElhbVBlcm1pc3Npb25zUmVzcG9uc2UiuAGC0+STApoBIkEvdjIve3Jlc291", + "cmNlPXByb2plY3RzLyovaW5zdGFuY2VzLyovdGFibGVzLyp9OnRlc3RJYW1Q", + "ZXJtaXNzaW9uczoBKlpSIk0vdjIve3Jlc291cmNlPXByb2plY3RzLyovaW5z", + "dGFuY2VzLyovY2x1c3RlcnMvKi9iYWNrdXBzLyp9OnRlc3RJYW1QZXJtaXNz", + "aW9uczoBKtpBFHJlc291cmNlLHBlcm1pc3Npb25zGt4CykEcYmlndGFibGVh", + "ZG1pbi5nb29nbGVhcGlzLmNvbdJBuwJodHRwczovL3d3dy5nb29nbGVhcGlz", + "LmNvbS9hdXRoL2JpZ3RhYmxlLmFkbWluLGh0dHBzOi8vd3d3Lmdvb2dsZWFw", + "aXMuY29tL2F1dGgvYmlndGFibGUuYWRtaW4udGFibGUsaHR0cHM6Ly93d3cu", + "Z29vZ2xlYXBpcy5jb20vYXV0aC9jbG91ZC1iaWd0YWJsZS5hZG1pbixodHRw", + "czovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2Nsb3VkLWJpZ3RhYmxlLmFk", + "bWluLnRhYmxlLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2xv", + "dWQtcGxhdGZvcm0saHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9j", + "bG91ZC1wbGF0Zm9ybS5yZWFkLW9ubHlCugEKHGNvbS5nb29nbGUuYmlndGFi", + "bGUuYWRtaW4udjJCF0JpZ3RhYmxlVGFibGVBZG1pblByb3RvUAFaPWdvb2ds", + "ZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvYmlndGFibGUvYWRt", + "aW4vdjI7YWRtaW6qAh5Hb29nbGUuQ2xvdWQuQmlndGFibGUuQWRtaW4uVjLK", + "Ah5Hb29nbGVcQ2xvdWRcQmlndGFibGVcQWRtaW5cVjJiBnByb3RvMw==")); 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.Cloud.Bigtable.Admin.V2.CommonReflection.Descriptor, global::Google.Cloud.Bigtable.Admin.V2.TableReflection.Descriptor, global::Google.Cloud.Iam.V1.IamPolicyReflection.Descriptor, global::Google.Cloud.Iam.V1.PolicyReflection.Descriptor, global::Google.LongRunning.OperationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { diff --git a/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2/BigtableTableAdminClient.g.cs b/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2/BigtableTableAdminClient.g.cs index 31eb67bdec5d..07e276c72766 100644 --- a/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2/BigtableTableAdminClient.g.cs +++ b/apis/Google.Cloud.Bigtable.Admin.V2/Google.Cloud.Bigtable.Admin.V2/BigtableTableAdminClient.g.cs @@ -2814,6 +2814,212 @@ public virtual void DeleteSnapshot(SnapshotName name, gaxgrpc::CallSettings call public virtual stt::Task> PollOnceCreateBackupAsync(string operationName, gaxgrpc::CallSettings callSettings = null) => lro::Operation.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), CreateBackupOperationsClient, callSettings); + /// + /// Starts creating a new Cloud Bigtable Backup. The returned backup + /// [long-running operation][google.longrunning.Operation] can be used to + /// track creation of the backup. The + /// [metadata][google.longrunning.Operation.metadata] field type is + /// [CreateBackupMetadata][google.bigtable.admin.v2.CreateBackupMetadata]. The + /// [response][google.longrunning.Operation.response] field type is + /// [Backup][google.bigtable.admin.v2.Backup], if successful. Cancelling the + /// returned operation will stop the creation and delete the backup. + /// + /// + /// Required. This must be one of the clusters in the instance in which this + /// table is located. The backup will be stored in this cluster. Values are + /// of the form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// + /// + /// Required. The id of the backup to be created. The `backup_id` along with + /// the parent `parent` are combined as {parent}/backups/{backup_id} to create + /// the full backup name, of the form: + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup_id}`. + /// This string must be between 1 and 50 characters in length and match the + /// regex [_a-zA-Z0-9][-_.a-zA-Z0-9]*. + /// + /// + /// Required. The backup to create. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation CreateBackup(string parent, string backupId, Backup backup, 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); + + /// + /// Starts creating a new Cloud Bigtable Backup. The returned backup + /// [long-running operation][google.longrunning.Operation] can be used to + /// track creation of the backup. The + /// [metadata][google.longrunning.Operation.metadata] field type is + /// [CreateBackupMetadata][google.bigtable.admin.v2.CreateBackupMetadata]. The + /// [response][google.longrunning.Operation.response] field type is + /// [Backup][google.bigtable.admin.v2.Backup], if successful. Cancelling the + /// returned operation will stop the creation and delete the backup. + /// + /// + /// Required. This must be one of the clusters in the instance in which this + /// table is located. The backup will be stored in this cluster. Values are + /// of the form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// + /// + /// Required. The id of the backup to be created. The `backup_id` along with + /// the parent `parent` are combined as {parent}/backups/{backup_id} to create + /// the full backup name, of the form: + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup_id}`. + /// This string must be between 1 and 50 characters in length and match the + /// regex [_a-zA-Z0-9][-_.a-zA-Z0-9]*. + /// + /// + /// Required. The backup to create. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(string parent, string backupId, Backup backup, 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); + + /// + /// Starts creating a new Cloud Bigtable Backup. The returned backup + /// [long-running operation][google.longrunning.Operation] can be used to + /// track creation of the backup. The + /// [metadata][google.longrunning.Operation.metadata] field type is + /// [CreateBackupMetadata][google.bigtable.admin.v2.CreateBackupMetadata]. The + /// [response][google.longrunning.Operation.response] field type is + /// [Backup][google.bigtable.admin.v2.Backup], if successful. Cancelling the + /// returned operation will stop the creation and delete the backup. + /// + /// + /// Required. This must be one of the clusters in the instance in which this + /// table is located. The backup will be stored in this cluster. Values are + /// of the form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// + /// + /// Required. The id of the backup to be created. The `backup_id` along with + /// the parent `parent` are combined as {parent}/backups/{backup_id} to create + /// the full backup name, of the form: + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup_id}`. + /// This string must be between 1 and 50 characters in length and match the + /// regex [_a-zA-Z0-9][-_.a-zA-Z0-9]*. + /// + /// + /// Required. The backup to create. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(string parent, string backupId, Backup backup, st::CancellationToken cancellationToken) => + CreateBackupAsync(parent, backupId, backup, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Starts creating a new Cloud Bigtable Backup. The returned backup + /// [long-running operation][google.longrunning.Operation] can be used to + /// track creation of the backup. The + /// [metadata][google.longrunning.Operation.metadata] field type is + /// [CreateBackupMetadata][google.bigtable.admin.v2.CreateBackupMetadata]. The + /// [response][google.longrunning.Operation.response] field type is + /// [Backup][google.bigtable.admin.v2.Backup], if successful. Cancelling the + /// returned operation will stop the creation and delete the backup. + /// + /// + /// Required. This must be one of the clusters in the instance in which this + /// table is located. The backup will be stored in this cluster. Values are + /// of the form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// + /// + /// Required. The id of the backup to be created. The `backup_id` along with + /// the parent `parent` are combined as {parent}/backups/{backup_id} to create + /// the full backup name, of the form: + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup_id}`. + /// This string must be between 1 and 50 characters in length and match the + /// regex [_a-zA-Z0-9][-_.a-zA-Z0-9]*. + /// + /// + /// Required. The backup to create. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation CreateBackup(ClusterName parent, string backupId, Backup backup, gaxgrpc::CallSettings callSettings = null) => + CreateBackup(new CreateBackupRequest + { + ParentAsClusterName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + BackupId = gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId)), + Backup = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + }, callSettings); + + /// + /// Starts creating a new Cloud Bigtable Backup. The returned backup + /// [long-running operation][google.longrunning.Operation] can be used to + /// track creation of the backup. The + /// [metadata][google.longrunning.Operation.metadata] field type is + /// [CreateBackupMetadata][google.bigtable.admin.v2.CreateBackupMetadata]. The + /// [response][google.longrunning.Operation.response] field type is + /// [Backup][google.bigtable.admin.v2.Backup], if successful. Cancelling the + /// returned operation will stop the creation and delete the backup. + /// + /// + /// Required. This must be one of the clusters in the instance in which this + /// table is located. The backup will be stored in this cluster. Values are + /// of the form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// + /// + /// Required. The id of the backup to be created. The `backup_id` along with + /// the parent `parent` are combined as {parent}/backups/{backup_id} to create + /// the full backup name, of the form: + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup_id}`. + /// This string must be between 1 and 50 characters in length and match the + /// regex [_a-zA-Z0-9][-_.a-zA-Z0-9]*. + /// + /// + /// Required. The backup to create. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(ClusterName parent, string backupId, Backup backup, gaxgrpc::CallSettings callSettings = null) => + CreateBackupAsync(new CreateBackupRequest + { + ParentAsClusterName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + BackupId = gax::GaxPreconditions.CheckNotNullOrEmpty(backupId, nameof(backupId)), + Backup = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + }, callSettings); + + /// + /// Starts creating a new Cloud Bigtable Backup. The returned backup + /// [long-running operation][google.longrunning.Operation] can be used to + /// track creation of the backup. The + /// [metadata][google.longrunning.Operation.metadata] field type is + /// [CreateBackupMetadata][google.bigtable.admin.v2.CreateBackupMetadata]. The + /// [response][google.longrunning.Operation.response] field type is + /// [Backup][google.bigtable.admin.v2.Backup], if successful. Cancelling the + /// returned operation will stop the creation and delete the backup. + /// + /// + /// Required. This must be one of the clusters in the instance in which this + /// table is located. The backup will be stored in this cluster. Values are + /// of the form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// + /// + /// Required. The id of the backup to be created. The `backup_id` along with + /// the parent `parent` are combined as {parent}/backups/{backup_id} to create + /// the full backup name, of the form: + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup_id}`. + /// This string must be between 1 and 50 characters in length and match the + /// regex [_a-zA-Z0-9][-_.a-zA-Z0-9]*. + /// + /// + /// Required. The backup to create. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> CreateBackupAsync(ClusterName parent, string backupId, Backup backup, st::CancellationToken cancellationToken) => + CreateBackupAsync(parent, backupId, backup, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + /// /// Gets metadata on a pending or completed Cloud Bigtable Backup. /// @@ -2841,6 +3047,96 @@ public virtual Backup GetBackup(GetBackupRequest request, gaxgrpc::CallSettings public virtual stt::Task GetBackupAsync(GetBackupRequest request, st::CancellationToken cancellationToken) => GetBackupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + /// + /// Gets metadata on a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. Name of the backup. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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 metadata on a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. Name of the backup. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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 metadata on a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. Name of the backup. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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 metadata on a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. Name of the backup. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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 metadata on a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. Name of the backup. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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 metadata on a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. Name of the backup. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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)); + /// /// Updates a pending or completed Cloud Bigtable Backup. /// @@ -2868,6 +3164,77 @@ public virtual Backup UpdateBackup(UpdateBackupRequest request, gaxgrpc::CallSet public virtual stt::Task UpdateBackupAsync(UpdateBackupRequest request, st::CancellationToken cancellationToken) => UpdateBackupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + /// + /// Updates a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. The backup to update. `backup.name`, and the fields to be updated + /// as specified by `update_mask` are required. Other fields are ignored. + /// Update is only supported for the following fields: + /// * `backup.expire_time`. + /// + /// + /// Required. A mask specifying which fields (e.g. `expire_time`) in the + /// Backup resource should be updated. This mask is relative to the Backup + /// resource, not to the request message. The field mask must always be + /// specified; this prevents any future fields from being erased accidentally + /// by clients that do not know about them. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual Backup UpdateBackup(Backup backup, wkt::FieldMask updateMask, gaxgrpc::CallSettings callSettings = null) => + UpdateBackup(new UpdateBackupRequest + { + Backup = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + UpdateMask = gax::GaxPreconditions.CheckNotNull(updateMask, nameof(updateMask)), + }, callSettings); + + /// + /// Updates a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. The backup to update. `backup.name`, and the fields to be updated + /// as specified by `update_mask` are required. Other fields are ignored. + /// Update is only supported for the following fields: + /// * `backup.expire_time`. + /// + /// + /// Required. A mask specifying which fields (e.g. `expire_time`) in the + /// Backup resource should be updated. This mask is relative to the Backup + /// resource, not to the request message. The field mask must always be + /// specified; this prevents any future fields from being erased accidentally + /// by clients that do not know about them. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task UpdateBackupAsync(Backup backup, wkt::FieldMask updateMask, gaxgrpc::CallSettings callSettings = null) => + UpdateBackupAsync(new UpdateBackupRequest + { + Backup = gax::GaxPreconditions.CheckNotNull(backup, nameof(backup)), + UpdateMask = gax::GaxPreconditions.CheckNotNull(updateMask, nameof(updateMask)), + }, callSettings); + + /// + /// Updates a pending or completed Cloud Bigtable Backup. + /// + /// + /// Required. The backup to update. `backup.name`, and the fields to be updated + /// as specified by `update_mask` are required. Other fields are ignored. + /// Update is only supported for the following fields: + /// * `backup.expire_time`. + /// + /// + /// Required. A mask specifying which fields (e.g. `expire_time`) in the + /// Backup resource should be updated. This mask is relative to the Backup + /// resource, not to the request message. The field mask must always be + /// specified; this prevents any future fields from being erased accidentally + /// by clients that do not know about them. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task UpdateBackupAsync(Backup backup, wkt::FieldMask updateMask, st::CancellationToken cancellationToken) => + UpdateBackupAsync(backup, updateMask, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + /// /// Deletes a pending or completed Cloud Bigtable backup. /// @@ -2895,6 +3262,96 @@ public virtual void DeleteBackup(DeleteBackupRequest request, gaxgrpc::CallSetti public virtual stt::Task DeleteBackupAsync(DeleteBackupRequest request, st::CancellationToken cancellationToken) => DeleteBackupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + /// + /// Deletes a pending or completed Cloud Bigtable backup. + /// + /// + /// Required. Name of the backup to delete. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual void DeleteBackup(string name, gaxgrpc::CallSettings callSettings = null) => + DeleteBackup(new DeleteBackupRequest + { + Name = gax::GaxPreconditions.CheckNotNullOrEmpty(name, nameof(name)), + }, callSettings); + + /// + /// Deletes a pending or completed Cloud Bigtable backup. + /// + /// + /// Required. Name of the backup to delete. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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 pending or completed Cloud Bigtable backup. + /// + /// + /// Required. Name of the backup to delete. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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 pending or completed Cloud Bigtable backup. + /// + /// + /// Required. Name of the backup to delete. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual void DeleteBackup(BackupName name, gaxgrpc::CallSettings callSettings = null) => + DeleteBackup(new DeleteBackupRequest + { + BackupName = gax::GaxPreconditions.CheckNotNull(name, nameof(name)), + }, callSettings); + + /// + /// Deletes a pending or completed Cloud Bigtable backup. + /// + /// + /// Required. Name of the backup to delete. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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 pending or completed Cloud Bigtable backup. + /// + /// + /// Required. Name of the backup to delete. + /// Values are of the form + /// `projects/{project}/instances/{instance}/clusters/{cluster}/backups/{backup}`. + /// + /// 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)); + /// /// Lists Cloud Bigtable backups. Returns both completed and pending /// backups. @@ -2915,6 +3372,118 @@ public virtual void DeleteBackup(DeleteBackupRequest request, gaxgrpc::CallSetti public virtual gax::PagedAsyncEnumerable ListBackupsAsync(ListBackupsRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException(); + /// + /// Lists Cloud Bigtable backups. Returns both completed and pending + /// backups. + /// + /// + /// Required. The cluster to list backups from. Values are of the + /// form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// Use `{cluster} = '-'` to list backups for all clusters in an instance, + /// e.g., `projects/{project}/instances/{instance}/clusters/-`. + /// + /// + /// 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 Cloud Bigtable backups. Returns both completed and pending + /// backups. + /// + /// + /// Required. The cluster to list backups from. Values are of the + /// form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// Use `{cluster} = '-'` to list backups for all clusters in an instance, + /// e.g., `projects/{project}/instances/{instance}/clusters/-`. + /// + /// + /// 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 Cloud Bigtable backups. Returns both completed and pending + /// backups. + /// + /// + /// Required. The cluster to list backups from. Values are of the + /// form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// Use `{cluster} = '-'` to list backups for all clusters in an instance, + /// e.g., `projects/{project}/instances/{instance}/clusters/-`. + /// + /// + /// 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(ClusterName parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) => + ListBackups(new ListBackupsRequest + { + ParentAsClusterName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + PageToken = pageToken ?? "", + PageSize = pageSize ?? 0, + }, callSettings); + + /// + /// Lists Cloud Bigtable backups. Returns both completed and pending + /// backups. + /// + /// + /// Required. The cluster to list backups from. Values are of the + /// form `projects/{project}/instances/{instance}/clusters/{cluster}`. + /// Use `{cluster} = '-'` to list backups for all clusters in an instance, + /// e.g., `projects/{project}/instances/{instance}/clusters/-`. + /// + /// + /// 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(ClusterName parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) => + ListBackupsAsync(new ListBackupsRequest + { + ParentAsClusterName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + PageToken = pageToken ?? "", + PageSize = pageSize ?? 0, + }, callSettings); + /// /// Create a new table by restoring from a completed backup. The new table /// must be in the same instance as the instance containing the backup. The diff --git a/apis/Google.Cloud.Bigtable.Admin.V2/synth.metadata b/apis/Google.Cloud.Bigtable.Admin.V2/synth.metadata index 5da0e493fb8b..f281c56f991a 100644 --- a/apis/Google.Cloud.Bigtable.Admin.V2/synth.metadata +++ b/apis/Google.Cloud.Bigtable.Admin.V2/synth.metadata @@ -1,18 +1,11 @@ { "sources": [ - { - "git": { - "name": ".", - "remote": "https://github.com/googleapis/google-cloud-dotnet.git", - "sha": "f3e627ac0972417f8af7e51937b3a8541c089cac" - } - }, { "git": { "name": "googleapis", "remote": "https://github.com/googleapis/googleapis.git", - "sha": "80dac49dd5f407b14f15ac86b4922967b5dd6508" + "sha": "756b174de4a122461993c1c583345533d819936d" } } ] -} \ No newline at end of file +}