/** * Creates a file system and waits for it to become available. We recommend to retry these requests * so that if you receive a timeout or server error and you won't run into the risk of creating multiple resources. * * @param fsClient the service client to use to create the File System * @param compartmentId the OCID of the compartment where the file system will be created * @param availabilityDomain the availability domain where the file system will be created * * @return the created file system */ private static async Task <FileSystem> CreateFileSystem(FileStorageClient fsClient, string compartmentId, string displayName, AvailabilityDomain availabilityDomain) { logger.Info("Creating file system......"); CreateFileSystemDetails createDetails = new CreateFileSystemDetails { DisplayName = displayName, CompartmentId = compartmentId, AvailabilityDomain = availabilityDomain.Name }; CreateFileSystemRequest createRequest = new CreateFileSystemRequest { CreateFileSystemDetails = createDetails }; CreateFileSystemResponse createResponse = await fsClient.CreateFileSystem(createRequest, new RetryConfiguration { MaxAttempts = 5 }); logger.Info($"Created file system: {createResponse.FileSystem.DisplayName}"); GetFileSystemRequest getRequest = new GetFileSystemRequest { FileSystemId = createResponse.FileSystem.Id }; GetFileSystemResponse getResponse = fsClient.Waiters.ForFileSystem(getRequest, FileSystem.LifecycleStateEnum.Active).Execute(); logger.Info($"Waited for file system to become available: {createResponse.FileSystem.DisplayName}"); return(getResponse.FileSystem); }
/// <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)); }
private void HandleOutput(GetFileSystemRequest request) { var waiterConfig = new WaiterConfiguration { MaxAttempts = MaxWaitAttempts, GetNextDelayInSeconds = (_) => WaitIntervalSeconds }; switch (ParameterSetName) { case LifecycleStateParamSet: response = client.Waiters.ForFileSystem(request, waiterConfig, WaitForLifecycleState).Execute(); break; case Default: response = client.GetFileSystem(request).GetAwaiter().GetResult(); break; } WriteOutput(response, response.FileSystem); }
protected override void ProcessRecord() { base.ProcessRecord(); GetFileSystemRequest request; try { request = new GetFileSystemRequest { FileSystemId = FileSystemId, OpcRequestId = OpcRequestId }; HandleOutput(request); FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
/** * 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(); }
/// <summary> /// Gets the specified file system's information. /// </summary> /// <param name="request"></param> /// <returns></returns> public async Task <GetFileSystemResponse> GetFileSystem(GetFileSystemRequest request) { var uri = new Uri($"{GetEndPoint(FileStorageServices.FileSystems, this.Region)}/{request.FileSystemId}"); var headers = new HttpRequestHeaderParam() { OpcRequestId = request.OpcRequestId }; var webResponse = await this.RestClientAsync.Get(uri, headers); using (var stream = webResponse.GetResponseStream()) using (var reader = new StreamReader(stream)) { var response = reader.ReadToEnd(); return(new GetFileSystemResponse() { FileSystem = this.JsonSerializer.Deserialize <FileSystem>(response), OpcRequestId = webResponse.Headers.Get("opc-request-id"), ETag = webResponse.Headers.Get("ETag") }); } }
/// <summary> /// Creates a waiter using default wait configuration. /// </summary> /// <param name="request">Request to send.</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, params FileSystem.LifecycleStateEnum[] targetStates) { return(this.ForFileSystem(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates)); }