private void HandleOutput(UpdateCloudVmClusterIormConfigRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForUpdateCloudVmClusterIormConfig(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.UpdateCloudVmClusterIormConfig(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.ExadataIormConfig);
}
private void HandleOutput(MigrateExadataDbSystemResourceModelRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForMigrateExadataDbSystemResourceModel(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.MigrateExadataDbSystemResourceModel(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.ExadataDbSystemMigration);
}
private void HandleOutput(StartAutonomousDatabaseRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForStartAutonomousDatabase(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.StartAutonomousDatabase(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.AutonomousDatabase);
}
private void HandleOutput(TerminateAutonomousContainerDatabaseRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForTerminateAutonomousContainerDatabase(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.TerminateAutonomousContainerDatabase(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId));
}
private void HandleOutput(FailoverDataGuardAssociationRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForFailoverDataGuardAssociation(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.FailoverDataGuardAssociation(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.DataGuardAssociation);
}
private void HandleOutput(ChangeDbSystemCompartmentRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForChangeDbSystemCompartment(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.ChangeDbSystemCompartment(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId));
}
private void HandleOutput(GetAutonomousExadataInfrastructureRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForAutonomousExadataInfrastructure(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetAutonomousExadataInfrastructure(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.AutonomousExadataInfrastructure);
}
private void HandleOutput(CompleteExternalBackupJobRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForCompleteExternalBackupJob(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.CompleteExternalBackupJob(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.ExternalBackupJob);
}
private void HandleOutput(GetDatabaseToolsEndpointServiceRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForDatabaseToolsEndpointService(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetDatabaseToolsEndpointService(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.DatabaseToolsEndpointService);
}
private void HandleOutput(GetSteeringPolicyAttachmentRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForSteeringPolicyAttachment(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetSteeringPolicyAttachment(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.SteeringPolicyAttachment);
}
private void HandleOutput(EnableExternalPluggableDatabaseOperationsInsightsRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForEnableExternalPluggableDatabaseOperationsInsights(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.EnableExternalPluggableDatabaseOperationsInsights(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId));
}
private static async Task DeleteStream(StreamAdminClient adminClient, String streamId)
{
logger.Info($"Deleting stream {streamId}");
DeleteStreamRequest deleteStreamRequest = new DeleteStreamRequest
{
StreamId = streamId
};
await adminClient.DeleteStream(deleteStreamRequest);
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
GetStreamRequest getStreamRequest = new GetStreamRequest
{
StreamId = streamId
};
adminClient.Waiters.ForStream(getStreamRequest, waiterConfiguration, Stream.LifecycleStateEnum.Deleted).Execute();
}
private static async Task terminateInstance(ComputeClient computeClient, Instance instance)
{
logger.Info($"Terminating Instance: {instance.Id}");
TerminateInstanceRequest terminateInstanceRequest = new TerminateInstanceRequest {
InstanceId = instance.Id
};
await computeClient.TerminateInstance(terminateInstanceRequest);
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
GetInstanceRequest getInstanceRequest = new GetInstanceRequest {
InstanceId = instance.Id
};
computeClient.Waiters.ForInstance(getInstanceRequest, waiterConfiguration, Instance.LifecycleStateEnum.Terminated).Execute();
logger.Info($"Terminated Instance: {instance.Id}");
}
private static async Task <Stream> GetOrCreateStream(StreamAdminClient client, string compartmentId, string streamName, int partitions)
{
ListStreamsRequest listRequest = new ListStreamsRequest
{
CompartmentId = compartmentId,
LifecycleState = Stream.LifecycleStateEnum.Active,
Name = streamName
};
ListStreamsResponse listStreamsResponse = await client.ListStreams(listRequest);
if (listStreamsResponse.Items.Count != 0)
{
// if we find an active stream with the correct name, we'll use it.
logger.Info($"An active stream named {streamName} was found");
string streamId = listStreamsResponse.Items[0].Id;
return(await GetStream(client, streamId));
}
logger.Info($"No active stream named {streamName} was found; creating it now");
Stream createdStream = await CreateStream(client, compartmentId, streamName, partitions);
// GetStream provides details about a specific stream.
// Since stream creation is asynchronous; we need to wait for the stream to become active.
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
GetStreamRequest streamRequest = new GetStreamRequest
{
StreamId = createdStream.Id
};
Stream activeStream = client.Waiters.ForStream(streamRequest, waiterConfiguration, Stream.LifecycleStateEnum.Active).Execute().Stream;
// Give a little time for the stream to be ready.
await Task.Delay(1000);
return(activeStream);
}
/**
* Deletes a mount target and waits for it to be deleted.
*
* @param fsClient the service client used to communicate with the File Storage service
* @param mountTarget the mount target to delete
*/
private static async Task DeleteMountTarget(FileStorageClient fsClient, MountTarget mountTarget)
{
logger.Info("Deleting mount target");
DeleteMountTargetRequest deleteRequest = new DeleteMountTargetRequest
{
MountTargetId = mountTarget.Id
};
await fsClient.DeleteMountTarget(deleteRequest);
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
GetMountTargetRequest getRequest = new GetMountTargetRequest
{
MountTargetId = mountTarget.Id
};
fsClient.Waiters.ForMountTarget(getRequest, waiterConfiguration, MountTarget.LifecycleStateEnum.Deleted).Execute();
}
private static async Task <Instance> createInstance(ComputeClient computeClient, LaunchInstanceDetails launchInstanceDetails)
{
logger.Info("Launching an instance.....");
LaunchInstanceRequest launchInstanceRequest = new LaunchInstanceRequest {
LaunchInstanceDetails = launchInstanceDetails
};
LaunchInstanceResponse launchInstanceResponse = await computeClient.LaunchInstance(launchInstanceRequest);
GetInstanceRequest getInstanceRequest = new GetInstanceRequest {
InstanceId = launchInstanceResponse.Instance.Id
};
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
GetInstanceResponse getInstanceResponse = computeClient.Waiters.ForInstance(getInstanceRequest, waiterConfiguration, Instance.LifecycleStateEnum.Running).Execute();
Instance instance = getInstanceResponse.Instance;
return(instance);
}
/**
* Deletes a file system and waits for it to be deleted.
*
* @param fsClient the service client used to communicate with the File Storage service
* @param fileSystem the file system to delete
*/
private static async Task DeleteFileSystem(FileStorageClient fsClient, FileSystem fileSystem)
{
logger.Info("Deleting file system");
DeleteFileSystemRequest deleteRequest = new DeleteFileSystemRequest
{
FileSystemId = fileSystem.Id
};
await fsClient.DeleteFileSystem(deleteRequest);
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
GetFileSystemRequest getRequest = new GetFileSystemRequest
{
FileSystemId = fileSystem.Id
};
fsClient.Waiters.ForFileSystem(getRequest, waiterConfiguration, FileSystem.LifecycleStateEnum.Deleted).Execute();
}
private static async Task CreateListener(LoadBalancerClient lbClient, string loadBalancerId, RuleSet ruleSet, string backendSetName)
{
logger.Info($"Creating new listener: {ListenerName} with ruleset: {RuleSetName}");
var ruleSetNames = new List <string>()
{
ruleSet.Name
};
var createListenerDetails = new CreateListenerDetails
{
Name = ListenerName,
DefaultBackendSetName = backendSetName,
Port = ListenerPort,
Protocol = ListenerProtocol,
RuleSetNames = ruleSetNames
};
var createListenerRequest = new CreateListenerRequest
{
CreateListenerDetails = createListenerDetails,
LoadBalancerId = loadBalancerId
};
var response = await lbClient.CreateListener(createListenerRequest);
var waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
var getWorkRequestRequest = new GetWorkRequestRequest
{
WorkRequestId = response.OpcWorkRequestId
};
lbClient.Waiters.ForWorkRequest(getWorkRequestRequest, waiterConfiguration, WorkRequest.LifecycleStateEnum.Succeeded).Execute();
logger.Info($"listener {ListenerName} is created");
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetTransferApplianceEntitlementRequest, GetTransferApplianceEntitlementResponse> ForTransferApplianceEntitlement(GetTransferApplianceEntitlementRequest request, WaiterConfiguration config, params TransferApplianceEntitlement.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetTransferApplianceEntitlementRequest, GetTransferApplianceEntitlementResponse>(
request,
request => client.GetTransferApplianceEntitlement(request),
response => targetStates.Contains(response.TransferApplianceEntitlement.LifecycleState.Value),
targetStates.Contains(TransferApplianceEntitlement.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetTransferApplianceEntitlementRequest, GetTransferApplianceEntitlementResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetDeploymentRequest, GetDeploymentResponse> ForDeployment(GetDeploymentRequest request, WaiterConfiguration config, params Deployment.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetDeploymentRequest, GetDeploymentResponse>(
request,
request => client.GetDeployment(request),
response => targetStates.Contains(response.Deployment.LifecycleState.Value),
targetStates.Contains(Deployment.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetDeploymentRequest, GetDeploymentResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetConnectHarnessRequest, GetConnectHarnessResponse> ForConnectHarness(GetConnectHarnessRequest request, WaiterConfiguration config, params ConnectHarness.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetConnectHarnessRequest, GetConnectHarnessResponse>(
request,
request => client.GetConnectHarness(request),
response => targetStates.Contains(response.ConnectHarness.LifecycleState.Value),
targetStates.Contains(ConnectHarness.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetConnectHarnessRequest, GetConnectHarnessResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetLogGroupRequest, GetLogGroupResponse> ForLogGroup(GetLogGroupRequest request, WaiterConfiguration config, params LogGroupLifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetLogGroupRequest, GetLogGroupResponse>(
request,
request => client.GetLogGroup(request),
response => targetStates.Contains(response.LogGroup.LifecycleState.Value)
);
return(new Waiter <GetLogGroupRequest, GetLogGroupResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetUnifiedAgentConfigurationRequest, GetUnifiedAgentConfigurationResponse> ForUnifiedAgentConfiguration(GetUnifiedAgentConfigurationRequest request, WaiterConfiguration config, params LogLifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetUnifiedAgentConfigurationRequest, GetUnifiedAgentConfigurationResponse>(
request,
request => client.GetUnifiedAgentConfiguration(request),
response => targetStates.Contains(response.UnifiedAgentConfiguration.LifecycleState.Value)
);
return(new Waiter <GetUnifiedAgentConfigurationRequest, GetUnifiedAgentConfigurationResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetCertificateRequest, GetCertificateResponse> ForCertificate(GetCertificateRequest request, WaiterConfiguration config, params LifecycleStates[] targetStates)
{
var agent = new WaiterAgent <GetCertificateRequest, GetCertificateResponse>(
request,
request => client.GetCertificate(request),
response => targetStates.Contains(response.Certificate.LifecycleState.Value),
targetStates.Contains(LifecycleStates.Deleted)
);
return(new Waiter <GetCertificateRequest, GetCertificateResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetAccessRequestRequest, GetAccessRequestResponse> ForAccessRequest(GetAccessRequestRequest request, WaiterConfiguration config, params AccessRequestLifecycleStates[] targetStates)
{
var agent = new WaiterAgent <GetAccessRequestRequest, GetAccessRequestResponse>(
request,
request => client.GetAccessRequest(request),
response => targetStates.Contains(response.AccessRequest.LifecycleState.Value)
);
return(new Waiter <GetAccessRequestRequest, GetAccessRequestResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetBootVolumeBackupRequest, GetBootVolumeBackupResponse> ForBootVolumeBackup(GetBootVolumeBackupRequest request, WaiterConfiguration config, params BootVolumeBackup.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetBootVolumeBackupRequest, GetBootVolumeBackupResponse>(
request,
request => client.GetBootVolumeBackup(request),
response => targetStates.Contains(response.BootVolumeBackup.LifecycleState.Value),
targetStates.Contains(BootVolumeBackup.LifecycleStateEnum.Terminated)
);
return(new Waiter <GetBootVolumeBackupRequest, GetBootVolumeBackupResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetFileSystemRequest, GetFileSystemResponse> ForFileSystem(GetFileSystemRequest request, WaiterConfiguration config, params FileSystem.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetFileSystemRequest, GetFileSystemResponse>(
request,
request => client.GetFileSystem(request),
response => targetStates.Contains(response.FileSystem.LifecycleState.Value),
targetStates.Contains(FileSystem.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetFileSystemRequest, GetFileSystemResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetWorkRequestRequest, GetWorkRequestResponse> ForWorkRequest(GetWorkRequestRequest request, WaiterConfiguration config, params WorkRequest.StatusEnum[] targetStates)
{
var agent = new WaiterAgent <GetWorkRequestRequest, GetWorkRequestResponse>(
request,
request => client.GetWorkRequest(request),
response => targetStates.Contains(response.WorkRequest.Status.Value)
);
return(new Waiter <GetWorkRequestRequest, GetWorkRequestResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetWorkspaceRequest, GetWorkspaceResponse> ForWorkspace(GetWorkspaceRequest request, WaiterConfiguration config, params Workspace.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetWorkspaceRequest, GetWorkspaceResponse>(
request,
request => client.GetWorkspace(request),
response => targetStates.Contains(response.Workspace.LifecycleState.Value),
targetStates.Contains(Workspace.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetWorkspaceRequest, GetWorkspaceResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetAnalyticsClusterRequest, GetAnalyticsClusterResponse> ForAnalyticsCluster(GetAnalyticsClusterRequest request, WaiterConfiguration config, params AnalyticsCluster.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetAnalyticsClusterRequest, GetAnalyticsClusterResponse>(
request,
request => client.GetAnalyticsCluster(request),
response => targetStates.Contains(response.AnalyticsCluster.LifecycleState.Value),
targetStates.Contains(AnalyticsCluster.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetAnalyticsClusterRequest, GetAnalyticsClusterResponse>(config, agent));
}
