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)); }