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