/**
* 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);
}
/**
* Creates a point in time snapshot of a file system and waits for it to become available. Note that snapshot
* names are immutable and must be unique amongst all non-DELETED snapshots for a file system.
*
* We recommend using a retry token on these requests so that if you receive a timeout or server error
* and need to retry the request you won't run the risk of creating multiple resources.
*
* @param fsClient the service client used to communicate with the File Storage service
* @param fileSystem the file system to create the snapshot of
*/
private static async Task <Snapshot> CreateSnapshot(FileStorageClient fsClient, FileSystem fileSystem)
{
logger.Info("Creating Snapshot...");
CreateSnapshotDetails createSnapshotDetails = new CreateSnapshotDetails
{
FileSystemId = fileSystem.Id,
Name = "example_snapshot"
};
CreateSnapshotRequest createRequest = new CreateSnapshotRequest
{
CreateSnapshotDetails = createSnapshotDetails
};
CreateSnapshotResponse createResponse = await fsClient.CreateSnapshot(createRequest);
logger.Info($"Created snapshot: {createResponse.Snapshot.Name}");
logger.Info($"Waiting for snapshot to become available");
GetSnapshotRequest getRequest = new GetSnapshotRequest
{
SnapshotId = createResponse.Snapshot.Id
};
GetSnapshotResponse getResponse = fsClient.Waiters.ForSnapshot(getRequest, Snapshot.LifecycleStateEnum.Active).Execute();
logger.Info($"Snapshot state: {getResponse.Snapshot.LifecycleState}");
return(getResponse.Snapshot);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
try
{
client?.Dispose();
int timeout = GetPreferredTimeout();
WriteDebug($"Cmdlet Timeout : {timeout} milliseconds.");
client = new FileStorageClient(AuthProvider, new Oci.Common.ClientConfiguration
{
RetryConfiguration = retryConfig,
TimeoutMillis = timeout,
ClientUserAgent = PSUserAgent
});
string region = GetPreferredRegion();
if (region != null)
{
WriteDebug("Choosing Region:" + region);
client.SetRegion(region);
}
if (Endpoint != null)
{
WriteDebug("Choosing Endpoint:" + Endpoint);
client.SetEndpoint(Endpoint);
}
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
/**
* Creates an export and waits for it to become available. This export enables us to access the file system
* via the mount target. We recommend using a retry token on these requests
* so that if you receive a timeout or server error and need to retry the request you won't run the risk of
* creating multiple resources.
*
* There are rules around export paths and file system associations which you should review here:
* https://docs.cloud.oracle.com/api/#/en/filestorage/20171215/Export/
*
* @param fsClient the service client to use to create the export
* @param fileSystemId the OCID of the file system to associate with the export
* @param exportSetId the OCID of the MountTarget's export set
*
* @return the created export
*/
private static async Task <Export> CreateExport(FileStorageClient fsClient, string fileSystemId, string exportSetId)
{
logger.Info("Creating export.....");
CreateExportDetails createExportDetails = new CreateExportDetails
{
ExportSetId = exportSetId,
FileSystemId = fileSystemId,
Path = ExportPath
};
CreateExportRequest createExportRequest = new CreateExportRequest
{
CreateExportDetails = createExportDetails
};
CreateExportResponse createResponse = await fsClient.CreateExport(createExportRequest,
new RetryConfiguration
{
MaxAttempts = 5
});
logger.Info($"Created Export");
logger.Info($"Waiting for export to become available");
GetExportRequest getRequest = new GetExportRequest
{
ExportId = createResponse.Export.Id
};
GetExportResponse getExportResponse = fsClient.Waiters.ForExport(getRequest, Export.LifecycleStateEnum.Active).Execute();
logger.Info($"Export path state: {getExportResponse.Export.LifecycleState}");
return(getExportResponse.Export);
}
/**
* Displays the export paths
*
* @param fsClient the service client to use to retrieve the exports
* @param listExportsRequest contains the parameters and filters to get the exports
*/
private static void IterateExports(FileStorageClient fsClient, ListExportsRequest listExportsRequest)
{
IEnumerable <ExportSummary> exportSummaries = fsClient.Paginators.ListExportsRecordEnumerator(listExportsRequest);
foreach (ExportSummary exportSummary in exportSummaries)
{
logger.Info($"Export path: {exportSummary.Path}");
}
}
/**
* Retrieves the details of an export set for a mount target
*
* @param exportSetId the OCID of the export set (obtained from a MountTarget)
*/
private static async Task GetExportSet(FileStorageClient fileStorageClient, string exportSetId)
{
logger.Info("Get export set for mount target");
GetExportSetRequest getExportSetRequest = new GetExportSetRequest
{
ExportSetId = exportSetId
};
GetExportSetResponse getExportSetResponse = await fileStorageClient.GetExportSet(getExportSetRequest);
logger.Info($"Export set for mount target: {getExportSetResponse.ExportSet.DisplayName}");
}
/**
* Deletes a snapshot and waits for it to be deleted.
*
* @param fsClient the service client used to communicate with the File Storage service
* @param snapshot the snapshot to delete
*/
private static async Task DeleteSnapshot(FileStorageClient fsClient, Snapshot snapshot)
{
logger.Info("Deleting snapshot");
DeleteSnapshotRequest deleteSnapshotRequest = new DeleteSnapshotRequest
{
SnapshotId = snapshot.Id
};
await fsClient.DeleteSnapshot(deleteSnapshotRequest);
GetSnapshotRequest getSnapshotRequest = new GetSnapshotRequest
{
SnapshotId = snapshot.Id
};
fsClient.Waiters.ForSnapshot(getSnapshotRequest, Snapshot.LifecycleStateEnum.Deleted).Execute();
}
/**
* Deletes an export and waits for it to be deleted.
*
* @param fsClient the service client used to communicate with the File Storage service
* @param export the export to delete
*/
private static async Task DeleteExport(FileStorageClient fsClient, Export export)
{
logger.Info("Deleting export");
DeleteExportRequest deleteExportRequest = new DeleteExportRequest
{
ExportId = export.Id
};
await fsClient.DeleteExport(deleteExportRequest);
GetExportRequest getExportRequest = new GetExportRequest
{
ExportId = export.Id
};
fsClient.Waiters.ForExport(getExportRequest, Export.LifecycleStateEnum.Deleted).Execute();
}
/**
* Creates a mount target 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.
*
* This creates a mount target WITHOUT specifying a hostname. This means that the mount target will only be accessible
* via its private IP address.
*
* @param fsClient the service client to use to create the mount target
* @param vcnClient a client used to communiate with the Virtual Networking service
* @param compartmentId the OCID of the compartment where the file system will be created
* @param displayName the display name of the mount target
* @param availabilityDomain the availability domain where the file system will be created
* @param subnet the subnet where the mount target will reside. If no private IP address is explicitly specified at
* creation time then the mount target will be assigned a free private IP address from the subnet
*
* @return the created mount target
*/
private static async Task <MountTarget> CreateMountTarget(FileStorageClient fsClient, VirtualNetworkClient vcnClient,
string compartmentId, string displayName, AvailabilityDomain availabilityDomain, Subnet subnet)
{
logger.Info("Creating mount target......");
CreateMountTargetDetails createDetails = new CreateMountTargetDetails
{
AvailabilityDomain = availabilityDomain.Name,
SubnetId = subnet.Id,
CompartmentId = compartmentId,
DisplayName = displayName
};
CreateMountTargetRequest createRequest = new CreateMountTargetRequest
{
CreateMountTargetDetails = createDetails
};
var retryConfiguration = new RetryConfiguration
{
MaxAttempts = 5
};
CreateMountTargetResponse createResponse = await fsClient.CreateMountTarget(createRequest, retryConfiguration);
logger.Info($"Created Mount target: {createResponse.MountTarget.DisplayName}");
logger.Info("Waiting for mount target to become available");
GetMountTargetRequest getRequest = new GetMountTargetRequest
{
MountTargetId = createResponse.MountTarget.Id
};
GetMountTargetResponse getResponse = fsClient.Waiters.ForMountTarget(getRequest, MountTarget.LifecycleStateEnum.Active).Execute();
logger.Info($"Mount target state: {getResponse.MountTarget.LifecycleState}");
string mountTargetPrivateIpId = getResponse.MountTarget.PrivateIpIds[0];
GetPrivateIpRequest getPrivateIpRequest = new GetPrivateIpRequest
{
PrivateIpId = mountTargetPrivateIpId
};
GetPrivateIpResponse getPrivateIpResponse = await vcnClient.GetPrivateIp(getPrivateIpRequest);
logger.Info($"Mount target private IP: {getPrivateIpResponse.PrivateIp.IpAddress}");
return(getResponse.MountTarget);
}
/**
* 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();
}
/**
* Demonstrates how to list exports and using various criteria. Note that listing exports is a paginated call, so we should
* get all pages until there is no more opcNextPage token
*
* @param fsClient the service client used to communicate with the File Storage service
* @param compartmentId the OCID of the compartment which owns the resources
* @param fileSystem the file system which we're working with
* @param mountTarget the mount target which we're working with
*/
private static void ListExports(FileStorageClient fsClient, String compartmentId, FileSystem fileSystem, MountTarget mountTarget)
{
// The most basic call is to list exports by comparment ID
ListExportsRequest listExportsRequest = new ListExportsRequest
{
CompartmentId = compartmentId
};
logger.Info("Listing exports by compartment ID");
IterateExports(fsClient, listExportsRequest);
// We can find all exports in a given export set
listExportsRequest.ExportSetId = mountTarget.ExportSetId;
logger.Info("Listing exports by export set");
IterateExports(fsClient, listExportsRequest);
// We can find all exports for a given file system
listExportsRequest.ExportSetId = null;
listExportsRequest.FileSystemId = fileSystem.Id;
logger.Info("Listing exports by file system");
IterateExports(fsClient, listExportsRequest);
}
/**
* 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();
}
public FileStorageWaiters(FileStorageClient client)
{
this.client = client;
}
public FileStoragePaginators(FileStorageClient client)
{
this.client = client;
}
public void WhenConnectionStringIsNull_ThenThrowException()
{
Assert.Throws <ArgumentNullException>(() => _ = new FileStorageClient(null, ShareName, false));
}
protected FileTestBase(string shareName)
{
ConnectionString = GetTestConnectionString();
_client = new FileStorageClient(ConnectionString, shareName, true);
}
public static async Task MainFileStorage()
{
logger.Info("Starting example");
var provider = new ConfigFileAuthenticationDetailsProvider("DEFAULT");
var compartmentId = Environment.GetEnvironmentVariable("OCI_COMPARTMENT_ID");
var fileSystemDisplayName = Environment.GetEnvironmentVariable("FILE_SYSTEM_DISPLAY_NAME");
var identityClient = new IdentityClient(provider);
var fileStorageClient = new FileStorageClient(provider);
var vcnClient = new VirtualNetworkClient(provider);
Vcn vcn = null;
Subnet subnet = null;
FileSystem fileSystem = null;
MountTarget mountTarget = null;
Export export = null;
Snapshot snapshot = null;
try
{
var availablityDomain = await GetAvailabilityDomain(identityClient, compartmentId);
logger.Info($"availability domain is {availablityDomain.Name}");
// A VCN and subnet is required to create a mount target
vcn = await CreateVcn(vcnClient, compartmentId);
subnet = await CreateSubnet(vcnClient, compartmentId, availablityDomain, vcn);
fileSystem = await CreateFileSystem(fileStorageClient, compartmentId,
fileSystemDisplayName, availablityDomain);
mountTarget = await CreateMountTarget(fileStorageClient, vcnClient,
compartmentId, fileSystemDisplayName + "-mnt", availablityDomain, subnet);
await GetExportSet(fileStorageClient, mountTarget.ExportSetId);
export = await CreateExport(fileStorageClient, fileSystem.Id, mountTarget.ExportSetId);
ListExports(fileStorageClient, compartmentId, fileSystem, mountTarget);
snapshot = await CreateSnapshot(fileStorageClient, fileSystem);
}
catch (Exception e)
{
logger.Error($"Failed to mount file system: {e}");
}
finally
{
logger.Info("cleaning resources....");
if (snapshot != null)
{
await DeleteSnapshot(fileStorageClient, snapshot);
}
if (export != null)
{
await DeleteExport(fileStorageClient, export);
}
if (mountTarget != null)
{
await DeleteMountTarget(fileStorageClient, mountTarget);
}
if (fileSystem != null)
{
await DeleteFileSystem(fileStorageClient, fileSystem);
}
if (subnet != null)
{
await DeleteSubnet(vcnClient, subnet);
}
if (vcn != null)
{
await DeleteVcn(vcnClient, vcn);
}
identityClient.Dispose();
fileStorageClient.Dispose();
vcnClient.Dispose();
logger.Info("End example");
}
}
public void WhenQueueNameIsNull_ThenThrowException()
{
Assert.Throws <ArgumentNullException>(() => _ = new FileStorageClient(TestConnectionStrings.Valid, null, false));
}
public void SetUp()
{
var connString = GetTestConnectionString();
_sut = new FileStorageClient(connString, ShareName, true);
}
