/// <summary>Snippet for ListTables</summary>
public void ListTables()
{
// Snippet: ListTables(InstanceName,string,int?,CallSettings)
// Create client
BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create();
// Initialize request argument(s)
InstanceName parent = new InstanceName("[PROJECT]", "[INSTANCE]");
// Make the request
PagedEnumerable <ListTablesResponse, Table> response =
bigtableTableAdminClient.ListTables(parent);
// Iterate over all response items, lazily performing RPCs as required
foreach (Table 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 (ListTablesResponse page in response.AsRawResponses())
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Table item in page)
{
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 <Table> 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 (Table item in singlePage)
{
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
public async Task <Backup> CreateBackupWithEncryptionKeyAsync(string projectId, string instanceId, string databaseId, string backupId, CryptoKeyName kmsKeyName)
{
// Create a DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Create the CreateBackupRequest with encryption configuration.
CreateBackupRequest request = new CreateBackupRequest
{
ParentAsInstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
BackupId = backupId,
Backup = new Backup
{
DatabaseAsDatabaseName = DatabaseName.FromProjectInstanceDatabase(projectId, instanceId, databaseId),
ExpireTime = DateTime.UtcNow.AddDays(14).ToTimestamp(),
},
EncryptionConfig = new CreateBackupEncryptionConfig
{
EncryptionType = CreateBackupEncryptionConfig.Types.EncryptionType.CustomerManagedEncryption,
KmsKeyNameAsCryptoKeyName = kmsKeyName,
},
};
// Execute the CreateBackup request.
var operation = await databaseAdminClient.CreateBackupAsync(request);
Console.WriteLine("Waiting for the operation to finish.");
// Poll until the returned long-running operation is complete.
var completedResponse = await operation.PollUntilCompletedAsync();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Error while creating backup: {completedResponse.Exception}");
throw completedResponse.Exception;
}
var backup = completedResponse.Result;
Console.WriteLine($"Backup {backup.Name} of size {backup.SizeBytes} bytes " +
$"was created at {backup.CreateTime} " +
$"using encryption key {kmsKeyName}");
return(backup);
}
public void DeleteInstance()
{
Mock <InstanceAdmin.InstanceAdminClient> mockGrpcClient = new Mock <InstanceAdmin.InstanceAdminClient>(MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient())
.Returns(new Mock <Operations.OperationsClient>().Object);
DeleteInstanceRequest expectedRequest = new DeleteInstanceRequest
{
InstanceName = new InstanceName("[PROJECT]", "[INSTANCE]"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteInstance(expectedRequest, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
InstanceAdminClient client = new InstanceAdminClientImpl(mockGrpcClient.Object, null);
InstanceName name = new InstanceName("[PROJECT]", "[INSTANCE]");
client.DeleteInstance(name);
mockGrpcClient.VerifyAll();
}
public async Task DeleteInstanceAsync()
{
Mock <InstanceAdmin.InstanceAdminClient> mockGrpcClient = new Mock <InstanceAdmin.InstanceAdminClient>(MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient())
.Returns(new Mock <Operations.OperationsClient>().Object);
DeleteInstanceRequest expectedRequest = new DeleteInstanceRequest
{
InstanceName = new InstanceName("[PROJECT]", "[INSTANCE]"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteInstanceAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
InstanceAdminClient client = new InstanceAdminClientImpl(mockGrpcClient.Object, null);
InstanceName name = new InstanceName("[PROJECT]", "[INSTANCE]");
await client.DeleteInstanceAsync(name);
mockGrpcClient.VerifyAll();
}
public BigtableFixtureBase()
{
GrpcInfo.EnableSubchannelCounting();
string emulatorHost = Environment.GetEnvironmentVariable(EmulatorEnvironmentVariable);
string projectId;
string instanceId;
if (!string.IsNullOrEmpty(emulatorHost))
{
projectId = "emulator-test-project";
EmulatorCallInvoker = new GcpCallInvoker(
emulatorHost,
ChannelCredentials.Insecure,
GrpcCoreAdapter.Instance.ConvertOptions(BigtableServiceApiSettings.GetDefault().CreateChannelOptions()));
instanceId = "doesnt-matter";
}
else
{
projectId = Environment.GetEnvironmentVariable(TestProjectEnvironmentVariable);
if (string.IsNullOrEmpty(projectId))
{
throw new InvalidOperationException(
$"Please set either the {EmulatorEnvironmentVariable} or {TestProjectEnvironmentVariable} environment variable before running tests");
}
instanceId = Environment.GetEnvironmentVariable(TestInstanceEnvironmentVariable);
if (string.IsNullOrEmpty(instanceId))
{
throw new InvalidOperationException(
$"Please set the {TestInstanceEnvironmentVariable} environment variable before running non-emulator tests.");
}
}
ProjectName = new ProjectName(projectId);
InstanceName = new InstanceName(projectId, instanceId);
Task.Run(InitBigtableInstanceAndTable).Wait();
}
public async stt::Task GetBackupResourceNamesAsync()
{
moq::Mock <CloudFilestoreManager.CloudFilestoreManagerClient> mockGrpcClient = new moq::Mock <CloudFilestoreManager.CloudFilestoreManagerClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetBackupRequest request = new GetBackupRequest
{
BackupName = BackupName.FromProjectLocationBackup("[PROJECT]", "[LOCATION]", "[BACKUP]"),
};
Backup expectedResponse = new Backup
{
BackupName = BackupName.FromProjectLocationBackup("[PROJECT]", "[LOCATION]", "[BACKUP]"),
Description = "description2cf9da67",
State = Backup.Types.State.Ready,
CreateTime = new wkt::Timestamp(),
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
CapacityGb = -8715396619027832166L,
StorageBytes = 8453704516828373557L,
SourceInstanceAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
SourceFileShare = "source_file_shareeecce468",
SourceInstanceTier = Instance.Types.Tier.Premium,
DownloadBytes = -6512123273633363558L,
SatisfiesPzs = false,
};
mockGrpcClient.Setup(x => x.GetBackupAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Backup>(stt::Task.FromResult(expectedResponse), null, null, null, null));
CloudFilestoreManagerClient client = new CloudFilestoreManagerClientImpl(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();
}
public void GetInstanceAuthStringResourceNames()
{
moq::Mock <CloudRedis.CloudRedisClient> mockGrpcClient = new moq::Mock <CloudRedis.CloudRedisClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetInstanceAuthStringRequest request = new GetInstanceAuthStringRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
InstanceAuthString expectedResponse = new InstanceAuthString
{
AuthString = "auth_string7b7a4b11",
};
mockGrpcClient.Setup(x => x.GetInstanceAuthString(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
CloudRedisClient client = new CloudRedisClientImpl(mockGrpcClient.Object, null);
InstanceAuthString response = client.GetInstanceAuthString(request.InstanceName);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
private async Task <bool> InitializeInstanceAsync()
{
InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();
InstanceName instanceName = InstanceName.FromProjectInstance(ProjectId, InstanceId);
try
{
Instance response = await instanceAdminClient.GetInstanceAsync(instanceName);
return(true);
}
catch (RpcException ex) when(ex.Status.StatusCode == StatusCode.NotFound)
{
CreateInstanceSample createInstanceSample = new CreateInstanceSample();
await SafeCreateInstanceAsync(() => Task.FromResult(createInstanceSample.CreateInstance(ProjectId, InstanceId)));
return(false);
}
}
private async Task CreateInstanceWithMultiRegionAsync()
{
InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();
var projectName = ProjectName.FromProject(ProjectId);
Instance instance = new Instance
{
DisplayName = "Multi-region samples test",
ConfigAsInstanceConfigName = InstanceConfigName.FromProjectInstanceConfig(ProjectId, InstanceConfigId),
InstanceName = InstanceName.FromProjectInstance(ProjectId, InstanceIdWithMultiRegion),
NodeCount = 1,
};
await SafeCreateInstanceAsync(async() =>
{
var response = await instanceAdminClient.CreateInstanceAsync(projectName, InstanceIdWithMultiRegion, instance);
// Poll until the returned long-running operation is complete
response = await response.PollUntilCompletedAsync();
return(response.Result);
});
}
public async stt::Task GetInstanceRequestObjectAsync()
{
moq::Mock <Instances.InstancesClient> mockGrpcClient = new moq::Mock <Instances.InstancesClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetInstanceRequest request = new GetInstanceRequest
{
Name = "name1c9368b0",
};
Instance expectedResponse = new Instance
{
InstanceName = InstanceName.FromAppServiceVersionInstance("[APP]", "[SERVICE]", "[VERSION]", "[INSTANCE]"),
Id = "id74b70bb8",
AppEngineRelease = "app_engine_release0d3b73e6",
Availability = Instance.Types.Availability.Unspecified,
VmName = "vm_name2b89e867",
VmZoneName = "vm_zone_name0deb2195",
VmId = "vm_idb8ec0c0e",
StartTime = new wkt::Timestamp(),
Requests = 821139506,
Errors = 20586759,
Qps = 1.5122795E+17F,
AverageLatency = -1548461605,
MemoryUsage = -2914232593404547833L,
VmStatus = "vm_status3752e225",
VmDebugEnabled = false,
VmIp = "vm_ipe63c1f99",
VmLiveness = Instance.Types.Liveness.Types.LivenessState.Draining,
};
mockGrpcClient.Setup(x => x.GetInstanceAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Instance>(stt::Task.FromResult(expectedResponse), null, null, null, null));
InstancesClient client = new InstancesClientImpl(mockGrpcClient.Object, null);
Instance responseCallSettings = await client.GetInstanceAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Instance responseCancellationToken = await client.GetInstanceAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public static Instance SpannerCreateInstance(string projectId, string instanceId)
{
// Create the InstanceAdminClient instance.
InstanceAdminClient instanceAdminClient = InstanceAdminClient.Create();
// Initialize request parameters.
Instance instance = new Instance
{
InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
ConfigAsInstanceConfigName =
InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-us-central1"),
DisplayName = "This is a display name.",
NodeCount = 1,
Labels =
{
{ "cloud_spanner_samples", "true" },
}
};
ProjectName parentAsProjectName = ProjectName.FromProject(projectId);
// Make the CreateInstance request.
Operation <Instance, CreateInstanceMetadata> response =
instanceAdminClient.CreateInstance(parentAsProjectName, instanceId, instance);
Console.WriteLine("Waiting for the operation to finish.");
// Poll until the returned long-running operation is complete.
Operation <Instance, CreateInstanceMetadata> completedResponse =
response.PollUntilCompleted();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Error while creating instance: {completedResponse.Exception}");
throw completedResponse.Exception;
}
Console.WriteLine($"Instance created successfully.");
return(completedResponse.Result);
}
private string GetExpressInstance()
{
string ExpressInstance = "";
try
{
String[] InstanceNames;
ExpressInstance = @"Server=localhost"; //.\SQLEXPRESS
// *******************************************************************************************
// * WORKS IN both x86 x64 mode
// *******************************************************************************************
RegistryKey localMachine = RegistryKey.OpenBaseKey(Microsoft.Win32.RegistryHive.LocalMachine, RegistryView.Registry64);
RegistryKey windowsNTKey = localMachine.OpenSubKey(@"SOFTWARE\Microsoft\Microsoft SQL Server");
InstanceNames = (String[])windowsNTKey.GetValue("InstalledInstances");
if (InstanceNames.Length == 1)
{
ExpressInstance = @"Server=.\" + InstanceNames[0];
}
else if (InstanceNames.Length > 0)
{
foreach (String InstanceName in InstanceNames)
{
if (InstanceName.Contains("EXPRESS"))
{
ExpressInstance = @"Server=.\" + InstanceName;
}
//Console.Write(element);
}
}
}
catch (Exception ex)
{
throw new Exception("Unable able to find SQL Server 2008 r2 Express Instance", ex);
}
return(ExpressInstance);
}
public async Task <Database> RestoreDatabaseWithEncryptionAsync(string projectId, string instanceId, string databaseId, string backupId, CryptoKeyName kmsKeyName)
{
// Create a DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Create the RestoreDatabaseRequest with encryption configuration.
RestoreDatabaseRequest request = new RestoreDatabaseRequest
{
ParentAsInstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
DatabaseId = databaseId,
BackupAsBackupName = BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId),
EncryptionConfig = new RestoreDatabaseEncryptionConfig
{
EncryptionType = RestoreDatabaseEncryptionConfig.Types.EncryptionType.CustomerManagedEncryption,
KmsKeyNameAsCryptoKeyName = kmsKeyName,
}
};
// Execute the RestoreDatabase request.
var operation = await databaseAdminClient.RestoreDatabaseAsync(request);
Console.WriteLine("Waiting for the operation to finish.");
// Poll until the returned long-running operation is complete.
var completedResponse = await operation.PollUntilCompletedAsync();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Error while restoring database: {completedResponse.Exception}");
throw completedResponse.Exception;
}
var database = completedResponse.Result;
var restoreInfo = database.RestoreInfo;
Console.WriteLine($"Database {restoreInfo.BackupInfo.SourceDatabase} " +
$"restored to {database.Name} " +
$"from backup {restoreInfo.BackupInfo.Backup} " +
$"using encryption key {database.EncryptionConfig.KmsKeyName}");
return(database);
}
public Backup CreateBackup(string projectId, string instanceId, string databaseId, string backupId, DateTime versionTime)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request parameters.
Backup backup = new Backup
{
DatabaseAsDatabaseName = DatabaseName.FromProjectInstanceDatabase(projectId, instanceId, databaseId),
ExpireTime = DateTime.UtcNow.AddDays(14).ToTimestamp(),
VersionTime = versionTime.ToTimestamp(),
};
InstanceName instanceName = InstanceName.FromProjectInstance(projectId, instanceId);
// Make the CreateBackup request.
Operation <Backup, CreateBackupMetadata> response = databaseAdminClient.CreateBackup(instanceName, backup, backupId);
Console.WriteLine("Waiting for the operation to finish.");
// Poll until the returned long-running operation is complete.
Operation <Backup, CreateBackupMetadata> completedResponse = response.PollUntilCompleted();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Error while creating backup: {completedResponse.Exception}");
throw completedResponse.Exception;
}
Console.WriteLine($"Backup created successfully.");
// GetBackup to get more information about the created backup.
BackupName backupName = BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId);
backup = databaseAdminClient.GetBackup(backupName);
Console.WriteLine($"Backup {backup.Name} of size {backup.SizeBytes} bytes " +
$"was created at {backup.CreateTime} from {backup.Database} " +
$"and is in state {backup.State} " +
$"and has version time {backup.VersionTime.ToDateTime()}");
return(backup);
}
public static object SpannerCancelBackupOperation(
string projectId, string instanceId, string databaseId, string backupId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request parameters.
Backup backup = new Backup
{
DatabaseAsDatabaseName =
DatabaseName.FromProjectInstanceDatabase(projectId, instanceId, databaseId),
ExpireTime = DateTime.UtcNow.AddDays(14).ToTimestamp()
};
InstanceName parentAsInstanceName = InstanceName.FromProjectInstance(projectId, instanceId);
// Make the CreateBackup request.
Operation <Backup, CreateBackupMetadata> operation =
databaseAdminClient.CreateBackup(parentAsInstanceName, backup, backupId);
// Cancel the operation.
operation.Cancel();
// Poll until the long-running operation is complete since the backup wasn't
// cancelled before it was created.
Console.WriteLine("Waiting for the operation to finish.");
Operation <Backup, CreateBackupMetadata> completedOperation =
operation.PollUntilCompleted();
if (!completedOperation.IsFaulted)
{
Console.WriteLine("Delete backup because it completed before it could be cancelled.");
BackupName backupAsBackupName =
BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId);
databaseAdminClient.DeleteBackup(backupAsBackupName);
}
Console.WriteLine($"Create backup operation cancelled: {operation.Name}");
return(0);
}
/// <summary>
/// Check The Given Table is exist or not in Google Cloud Bigtable
/// </summary>
/// <returns></returns>
public bool IsTableExists()
{
SetEnvironmentVariable();
if (!CheckProperty())
{
throw new Exception("One Or More Properties Not Set");
}
bool exists = false;
try
{
BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create();
InstanceName instanceName = new InstanceName(ProjectId, InstanceId);
var tables = bigtableTableAdminClient.ListTables(instanceName);
exists = tables.Any(x => x.TableName.TableId == TableName);
}
catch (Exception ex)
{
throw ex;
}
return(exists);
}
public async Task <Instance> CloudHealthAsync()
{
CloudRedisClient cloudRedisClient = CloudRedisClient.Create(channel);
// Initialize request argument(s)
InstanceName name = new InstanceName(
configuration["GCPSetting:PROJECTNAME"],
configuration["GCPSetting:LOCATIONNAME"],
configuration["GCPSetting:INSTANCES:RedisINSTANCES"]
);
// Make the request
Instance response = await cloudRedisClient.GetInstanceAsync(name);
if (response != null)
{
return(response);
}
else
{
return(null);
}
}
public static void DelelteBackups()
{
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
//delete backup contains "a"
var dataTime = DateTime.UtcNow.AddDays(1).ToString("yyyy-MM-dd");
var listBackupRequest = new ListBackupsRequest
{
Parent = InstanceName.Format(projectId, instanceId),
Filter = $"create_time < {dataTime}"
};
var backups = databaseAdminClient.ListBackups(listBackupRequest);
foreach (var backup in backups)
{
var deleteBackupRequest = new DeleteBackupRequest()
{
Name = backup.Name
};
databaseAdminClient.DeleteBackup(deleteBackupRequest);
}
}
public void Get_unknownInformation_throwsKeyNotFoundException <TObject>(string iName, TObject dummyObject)
{
// arrange:
List <object> mocks = new List <object>();
InstanceName <TObject> name = new InstanceName <TObject>(iName);
EnvironmentChainLinkBase firstMockLink;
EnvironmentChainLinkBase secondMockLink;
EnvironmentsChain underTest = CreateNewEnvironmentChainToTest(out firstMockLink, out secondMockLink);
mocks.Add(firstMockLink);
mocks.Add(secondMockLink);
TObject varPlaceHolder;
firstMockLink.Expect(l => l.TryGet <TObject>(name, out varPlaceHolder)).Return(false).Repeat.Once();
secondMockLink.Expect(l => l.TryGet <TObject>(name, out varPlaceHolder)).Return(false).Repeat.Once();
// assert:
Assert.Throws <KeyNotFoundException>(delegate { underTest.Get <TObject>(name); });
foreach (object mock in mocks)
{
mock.VerifyAllExpectations();
}
}
public IEnumerable <Operation> ListBackupOperations(string projectId, string instanceId, string databaseId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
var filter = $"(metadata.database:{databaseId}) AND (metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata)";
ListBackupOperationsRequest request = new ListBackupOperationsRequest
{
ParentAsInstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
Filter = filter
};
// List the create backup operations on the database.
var backupOperations = databaseAdminClient.ListBackupOperations(request);
foreach (var operation in backupOperations)
{
CreateBackupMetadata metadata = operation.Metadata.Unpack <CreateBackupMetadata>();
Console.WriteLine($"Backup {metadata.Name} on " + $"database {metadata.Database} is " + $"{metadata.Progress.ProgressPercent}% complete");
}
return(backupOperations);
}
public async Task TestIamPermissionsAsync()
{
Mock <InstanceAdmin.InstanceAdminClient> mockGrpcClient = new Mock <InstanceAdmin.InstanceAdminClient>(MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient())
.Returns(new Mock <Operations.OperationsClient>().Object);
TestIamPermissionsRequest expectedRequest = new TestIamPermissionsRequest
{
Resource = new InstanceName("[PROJECT]", "[INSTANCE]").ToString(),
Permissions = { },
};
TestIamPermissionsResponse expectedResponse = new TestIamPermissionsResponse();
mockGrpcClient.Setup(x => x.TestIamPermissionsAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <TestIamPermissionsResponse>(Task.FromResult(expectedResponse), null, null, null, null));
InstanceAdminClient client = new InstanceAdminClientImpl(mockGrpcClient.Object, null);
string formattedResource = new InstanceName("[PROJECT]", "[INSTANCE]").ToString();
IEnumerable <string> permissions = new List <string>();
TestIamPermissionsResponse response = await client.TestIamPermissionsAsync(formattedResource, permissions);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>Snippet for FailoverInstanceAsync</summary>
public async Task FailoverInstanceAsync()
{
// Snippet: FailoverInstanceAsync(InstanceName,FailoverInstanceRequest.Types.DataProtectionMode,CallSettings)
// Additional: FailoverInstanceAsync(InstanceName,FailoverInstanceRequest.Types.DataProtectionMode,CancellationToken)
// Create client
CloudRedisClient cloudRedisClient = await CloudRedisClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = new InstanceName("[PROJECT]", "[LOCATION]", "[INSTANCE]");
FailoverInstanceRequest.Types.DataProtectionMode dataProtectionMode = FailoverInstanceRequest.Types.DataProtectionMode.Unspecified;
// Make the request
Operation <Instance, OperationMetadata> response =
await cloudRedisClient.FailoverInstanceAsync(name, dataProtectionMode);
// Poll until the returned long-running operation is complete
Operation <Instance, OperationMetadata> completedResponse =
await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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 <Instance, OperationMetadata> retrievedResponse =
await cloudRedisClient.PollOnceFailoverInstanceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
// End snippet
}
/// <summary>Snippet for CreateInstanceAsync</summary>
public async Task CreateInstanceAsync()
{
// Snippet: CreateInstanceAsync(ProjectName,InstanceName,Instance,CallSettings)
// Additional: CreateInstanceAsync(ProjectName,InstanceName,Instance,CancellationToken)
// Create client
InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = new ProjectName("[PROJECT]");
InstanceName instanceId = new InstanceName("[PROJECT]", "[INSTANCE]");
Instance instance = new Instance();
// Make the request
Operation <Instance, CreateInstanceMetadata> response =
await instanceAdminClient.CreateInstanceAsync(parent, instanceId, instance);
// Poll until the returned long-running operation is complete
Operation <Instance, CreateInstanceMetadata> completedResponse =
await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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 <Instance, CreateInstanceMetadata> retrievedResponse =
await instanceAdminClient.PollOnceCreateInstanceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
// End snippet
}
public async stt::Task GetInstanceAuthStringResourceNamesAsync()
{
moq::Mock <CloudRedis.CloudRedisClient> mockGrpcClient = new moq::Mock <CloudRedis.CloudRedisClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetInstanceAuthStringRequest request = new GetInstanceAuthStringRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
InstanceAuthString expectedResponse = new InstanceAuthString
{
AuthString = "auth_string7b7a4b11",
};
mockGrpcClient.Setup(x => x.GetInstanceAuthStringAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <InstanceAuthString>(stt::Task.FromResult(expectedResponse), null, null, null, null));
CloudRedisClient client = new CloudRedisClientImpl(mockGrpcClient.Object, null);
InstanceAuthString responseCallSettings = await client.GetInstanceAuthStringAsync(request.InstanceName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
InstanceAuthString responseCancellationToken = await client.GetInstanceAuthStringAsync(request.InstanceName, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public async Task GetInstanceAsync()
{
Mock <CloudRedis.CloudRedisClient> mockGrpcClient = new Mock <CloudRedis.CloudRedisClient>(MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient())
.Returns(new Mock <Operations.OperationsClient>().Object);
GetInstanceRequest expectedRequest = new GetInstanceRequest
{
InstanceName = new InstanceName("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
Instance expectedResponse = new Instance
{
Name = "name2-1052831874",
DisplayName = "displayName1615086568",
LocationId = "locationId552319461",
AlternativeLocationId = "alternativeLocationId-718920621",
RedisVersion = "redisVersion-685310444",
ReservedIpRange = "reservedIpRange-1082940580",
Host = "host3208616",
Port = 3446913,
CurrentLocationId = "currentLocationId1312712735",
StatusMessage = "statusMessage-239442758",
MemorySizeGb = 34199707,
AuthorizedNetwork = "authorizedNetwork-1733809270",
PersistenceIamIdentity = "persistenceIamIdentity1061944584",
};
mockGrpcClient.Setup(x => x.GetInstanceAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Instance>(Task.FromResult(expectedResponse), null, null, null, null));
CloudRedisClient client = new CloudRedisClientImpl(mockGrpcClient.Object, null);
InstanceName name = new InstanceName("[PROJECT]", "[LOCATION]", "[INSTANCE]");
Instance response = await client.GetInstanceAsync(name);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public static object SpannerRestoreDatabase(
string projectId, string instanceId, string databaseId, string backupId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
InstanceName parentAsInstanceName =
InstanceName.FromProjectInstance(projectId, instanceId);
BackupName backupAsBackupName =
BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId);
// Make the RestoreDatabase request.
Operation <Database, RestoreDatabaseMetadata> response =
databaseAdminClient.RestoreDatabase(
parentAsInstanceName, databaseId, backupAsBackupName);
Console.WriteLine("Waiting for the operation to finish");
// Poll until the returned long-running operation is complete.
var completedResponse = response.PollUntilCompleted();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Database Restore Failed: {completedResponse.Exception}");
return(1);
}
RestoreInfo restoreInfo = completedResponse.Result.RestoreInfo;
Console.WriteLine(
$"Database {restoreInfo.BackupInfo.SourceDatabase} was restored " +
$"to {databaseId} from backup {restoreInfo.BackupInfo.Backup} " +
$"with version time {restoreInfo.BackupInfo.VersionTime.ToDateTime()}");
return(0);
}
public BigtableFixtureBase()
{
string emulatorHost = Environment.GetEnvironmentVariable(EmulatorEnvironmentVariable);
string projectId;
string instanceId;
if (!string.IsNullOrEmpty(emulatorHost))
{
projectId = "emulator-test-project";
EmulatorChannel = new Channel(emulatorHost, ChannelCredentials.Insecure);
instanceId = "doesnt-matter";
}
else
{
projectId = Environment.GetEnvironmentVariable(TestProjectEnvironmentVariable);
if (string.IsNullOrEmpty(projectId))
{
throw new InvalidOperationException(
$"Please set either the {EmulatorEnvironmentVariable} or {TestProjectEnvironmentVariable} environment variable before running tests");
}
instanceId = Environment.GetEnvironmentVariable(TestInstanceEnvironmentVariable);
if (string.IsNullOrEmpty(instanceId))
{
throw new InvalidOperationException(
$"Please set the {TestInstanceEnvironmentVariable} environment variable before running non-emulator tests.");
}
}
ProjectName = new ProjectName(projectId);
InstanceName = new InstanceName(projectId, instanceId);
Task.Run(InitBigtableInstanceAndTable).Wait();
}
/// <summary>
/// Validates this instance.
/// </summary>
/// <exception cref="System.ArgumentException">
/// InstanceName must be set
/// or
/// TenantId must be set
/// or
/// SubscriptionId must be set
/// or
/// SharedAccessPolicy must be set
/// </exception>
/// <exception cref="ArgumentException">InstanceName must be set and AppId must be set and AppId must be set and
/// TenantId must be set and SubscriptionId must be set.</exception>
/// <inheritdoc />
public override void Validate()
{
if (InstanceName.IsNullOrEmpty())
{
throw new ArgumentException("InstanceName must be set");
}
if (TenantId.IsNullOrEmpty())
{
throw new ArgumentException("TenantId must be set");
}
if (SubscriptionId.IsNullOrEmpty())
{
throw new ArgumentException("SubscriptionId must be set");
}
if (SharedAccessPolicyName.IsNullOrEmpty())
{
throw new ArgumentException("SharedAccessPolicy must be set");
}
base.Validate();
}
/// <summary>Snippet for CreateClusterAsync</summary>
public async Task CreateClusterAsync()
{
// Snippet: CreateClusterAsync(InstanceName,string,Cluster,CallSettings)
// Additional: CreateClusterAsync(InstanceName,string,Cluster,CancellationToken)
// Create client
BigtableInstanceAdminClient bigtableInstanceAdminClient = await BigtableInstanceAdminClient.CreateAsync();
// Initialize request argument(s)
InstanceName parent = new InstanceName("[PROJECT]", "[INSTANCE]");
string clusterId = "";
Cluster cluster = new Cluster();
// Make the request
Operation <Cluster, CreateClusterMetadata> response =
await bigtableInstanceAdminClient.CreateClusterAsync(parent, clusterId, cluster);
// Poll until the returned long-running operation is complete
Operation <Cluster, CreateClusterMetadata> completedResponse =
await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster 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 <Cluster, CreateClusterMetadata> retrievedResponse =
await bigtableInstanceAdminClient.PollOnceCreateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Cluster retrievedResult = retrievedResponse.Result;
}
// End snippet
}
protected virtual void ConfigureServerName(
dynamic /*SqlConnectionStringBuilder*/ builder)
{
var dataSource = ServerName.NullIfEmpty() ?? LocalServerName;
if (ServerPort.HasValue || InstanceName.HasContent())
{
var s = new StringBuilder(dataSource);
if (InstanceName.HasContent())
{
s.Append('\\').Append(InstanceName);
}
if (ServerPort.HasValue)
{
s.Append(',').Append(ServerPort.Value.ToString(CultureInfo.InvariantCulture));
}
dataSource = s.ToString();
}
builder.DataSource = dataSource;
}
