com.amazonaws.services.fsx.AmazonFSxClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-fsx Show documentation
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.fsx;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.fsx.AmazonFSxClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.fsx.model.*;
import com.amazonaws.services.fsx.model.transform.*;
/**
* Client for accessing Amazon FSx. All service calls made using this client are blocking, and will not return until the
* service call completes.
*
*
* Amazon FSx is a fully managed service that makes it easy for storage and application administrators to launch and use
* shared file storage.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonFSxClient extends AmazonWebServiceClient implements AmazonFSx {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonFSx.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "fsx";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidImportPath").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InvalidImportPathExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidNetworkSettings").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InvalidNetworkSettingsExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("IncompatibleRegionForMultiAZ").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.IncompatibleRegionForMultiAZExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("FileSystemNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.FileSystemNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("DataRepositoryAssociationNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.DataRepositoryAssociationNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceDoesNotSupportTagging").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.ResourceDoesNotSupportTaggingExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("DataRepositoryTaskNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.DataRepositoryTaskNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("SourceBackupUnavailable").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.SourceBackupUnavailableExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.ResourceNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("UnsupportedOperation").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.UnsupportedOperationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("StorageVirtualMachineNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.StorageVirtualMachineNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("BackupRestoring").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.BackupRestoringExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("BackupInProgress").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.BackupInProgressExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidExportPath").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InvalidExportPathExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidRegion").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InvalidRegionExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("MissingVolumeConfiguration").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.MissingVolumeConfigurationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidSourceKmsKey").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InvalidSourceKmsKeyExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("DataRepositoryTaskExecuting").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.DataRepositoryTaskExecutingExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("MissingFileCacheConfiguration").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.MissingFileCacheConfigurationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("BackupNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.BackupNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("FileCacheNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.FileCacheNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidDestinationKmsKey").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InvalidDestinationKmsKeyExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("VolumeNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.VolumeNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServiceLimitExceeded").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.ServiceLimitExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("NotServiceResourceError").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.NotServiceResourceErrorExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("MissingFileSystemConfiguration").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.MissingFileSystemConfigurationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("BackupBeingCopied").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.BackupBeingCopiedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("IncompatibleParameterError").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.IncompatibleParameterErrorExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("DataRepositoryTaskEnded").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.DataRepositoryTaskEndedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidDataRepositoryType").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InvalidDataRepositoryTypeExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("SnapshotNotFound").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.SnapshotNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidPerUnitStorageThroughput").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InvalidPerUnitStorageThroughputExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ActiveDirectoryError").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.ActiveDirectoryErrorExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("BadRequest").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.BadRequestExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InternalServerError").withExceptionUnmarshaller(
com.amazonaws.services.fsx.model.transform.InternalServerErrorExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.fsx.model.AmazonFSxException.class));
public static AmazonFSxClientBuilder builder() {
return AmazonFSxClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon FSx using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonFSxClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on Amazon FSx using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonFSxClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("fsx.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/fsx/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/fsx/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Use this action to associate one or more Domain Name Server (DNS) aliases with an existing Amazon FSx for Windows
* File Server file system. A file system can have a maximum of 50 DNS aliases associated with it at any one time.
* If you try to associate a DNS alias that is already associated with the file system, FSx takes no action on that
* alias in the request. For more information, see Working with DNS Aliases
* and
* Walkthrough 5: Using DNS aliases to access your file system, including additional steps you must take to be
* able to access your file system using a DNS alias.
*
*
* The system response shows the DNS aliases that Amazon FSx is attempting to associate with the file system. Use
* the API operation to monitor the status of the aliases Amazon FSx is associating with the file system.
*
*
* @param associateFileSystemAliasesRequest
* The request object specifying one or more DNS alias names to associate with an Amazon FSx for Windows File
* Server file system.
* @return Result of the AssociateFileSystemAliases operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.AssociateFileSystemAliases
* @see AWS
* API Documentation
*/
@Override
public AssociateFileSystemAliasesResult associateFileSystemAliases(AssociateFileSystemAliasesRequest request) {
request = beforeClientExecution(request);
return executeAssociateFileSystemAliases(request);
}
@SdkInternalApi
final AssociateFileSystemAliasesResult executeAssociateFileSystemAliases(AssociateFileSystemAliasesRequest associateFileSystemAliasesRequest) {
ExecutionContext executionContext = createExecutionContext(associateFileSystemAliasesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssociateFileSystemAliasesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(associateFileSystemAliasesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssociateFileSystemAliases");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new AssociateFileSystemAliasesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Cancels an existing Amazon FSx for Lustre data repository task if that task is in either the PENDING
* or EXECUTING state. When you cancel am export task, Amazon FSx does the following.
*
*
* -
*
* Any files that FSx has already exported are not reverted.
*
*
* -
*
* FSx continues to export any files that are in-flight when the cancel operation is received.
*
*
* -
*
* FSx does not export any files that have not yet been exported.
*
*
*
*
* For a release task, Amazon FSx will stop releasing files upon cancellation. Any files that have already been
* released will remain in the released state.
*
*
* @param cancelDataRepositoryTaskRequest
* Cancels a data repository task.
* @return Result of the CancelDataRepositoryTask operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @throws DataRepositoryTaskNotFoundException
* The data repository task or tasks you specified could not be found.
* @throws DataRepositoryTaskEndedException
* The data repository task could not be canceled because the task has already ended.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.CancelDataRepositoryTask
* @see AWS
* API Documentation
*/
@Override
public CancelDataRepositoryTaskResult cancelDataRepositoryTask(CancelDataRepositoryTaskRequest request) {
request = beforeClientExecution(request);
return executeCancelDataRepositoryTask(request);
}
@SdkInternalApi
final CancelDataRepositoryTaskResult executeCancelDataRepositoryTask(CancelDataRepositoryTaskRequest cancelDataRepositoryTaskRequest) {
ExecutionContext executionContext = createExecutionContext(cancelDataRepositoryTaskRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelDataRepositoryTaskRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(cancelDataRepositoryTaskRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelDataRepositoryTask");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CancelDataRepositoryTaskResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Copies an existing backup within the same Amazon Web Services account to another Amazon Web Services Region
* (cross-Region copy) or within the same Amazon Web Services Region (in-Region copy). You can have up to five
* backup copy requests in progress to a single destination Region per account.
*
*
* You can use cross-Region backup copies for cross-Region disaster recovery. You can periodically take backups and
* copy them to another Region so that in the event of a disaster in the primary Region, you can restore from backup
* and recover availability quickly in the other Region. You can make cross-Region copies only within your Amazon
* Web Services partition. A partition is a grouping of Regions. Amazon Web Services currently has three partitions:
* aws (Standard Regions), aws-cn (China Regions), and aws-us-gov (Amazon Web
* Services GovCloud [US] Regions).
*
*
* You can also use backup copies to clone your file dataset to another Region or within the same Region.
*
*
* You can use the SourceRegion parameter to specify the Amazon Web Services Region from which the
* backup will be copied. For example, if you make the call from the us-west-1 Region and want to copy
* a backup from the us-east-2 Region, you specify us-east-2 in the
* SourceRegion parameter to make a cross-Region copy. If you don't specify a Region, the backup copy
* is created in the same Region where the request is sent from (in-Region copy).
*
*
* For more information about creating backup copies, see Copying backups
* in the Amazon FSx for Windows User Guide, Copying backups
* in the Amazon FSx for Lustre User Guide, and Copying backups in
* the Amazon FSx for OpenZFS User Guide.
*
*
* @param copyBackupRequest
* @return Result of the CopyBackup operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws BackupNotFoundException
* No Amazon FSx backups were found based upon the supplied parameters.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws InvalidSourceKmsKeyException
* The Key Management Service (KMS) key of the source backup is not valid.
* @throws InvalidDestinationKmsKeyException
* The Key Management Service (KMS) key of the destination backup is not valid.
* @throws InvalidRegionException
* The Region provided for SourceRegion is not valid or is in a different Amazon Web Services
* partition.
* @throws SourceBackupUnavailableException
* The request was rejected because the lifecycle status of the source backup isn't AVAILABLE.
* @throws IncompatibleRegionForMultiAZException
* Amazon FSx doesn't support Multi-AZ Windows File Server copy backup in the destination Region, so the
* copied backup can't be restored.
* @sample AmazonFSx.CopyBackup
* @see AWS API
* Documentation
*/
@Override
public CopyBackupResult copyBackup(CopyBackupRequest request) {
request = beforeClientExecution(request);
return executeCopyBackup(request);
}
@SdkInternalApi
final CopyBackupResult executeCopyBackup(CopyBackupRequest copyBackupRequest) {
ExecutionContext executionContext = createExecutionContext(copyBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyBackupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(copyBackupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopyBackup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new CopyBackupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an existing volume by using a snapshot from another Amazon FSx for OpenZFS file system. For more
* information, see on-demand data
* replication in the Amazon FSx for OpenZFS User Guide.
*
*
* @param copySnapshotAndUpdateVolumeRequest
* @return Result of the CopySnapshotAndUpdateVolume operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @sample AmazonFSx.CopySnapshotAndUpdateVolume
* @see AWS API Documentation
*/
@Override
public CopySnapshotAndUpdateVolumeResult copySnapshotAndUpdateVolume(CopySnapshotAndUpdateVolumeRequest request) {
request = beforeClientExecution(request);
return executeCopySnapshotAndUpdateVolume(request);
}
@SdkInternalApi
final CopySnapshotAndUpdateVolumeResult executeCopySnapshotAndUpdateVolume(CopySnapshotAndUpdateVolumeRequest copySnapshotAndUpdateVolumeRequest) {
ExecutionContext executionContext = createExecutionContext(copySnapshotAndUpdateVolumeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopySnapshotAndUpdateVolumeRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(copySnapshotAndUpdateVolumeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopySnapshotAndUpdateVolume");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CopySnapshotAndUpdateVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a backup of an existing Amazon FSx for Windows File Server file system, Amazon FSx for Lustre file
* system, Amazon FSx for NetApp ONTAP volume, or Amazon FSx for OpenZFS file system. We recommend creating regular
* backups so that you can restore a file system or volume from a backup if an issue arises with the original file
* system or volume.
*
*
* For Amazon FSx for Lustre file systems, you can create a backup only for file systems that have the following
* configuration:
*
*
* -
*
* A Persistent deployment type
*
*
* -
*
* Are not linked to a data repository
*
*
*
*
* For more information about backups, see the following:
*
*
* -
*
* For Amazon FSx for Lustre, see Working with FSx for Lustre
* backups.
*
*
* -
*
* For Amazon FSx for Windows, see Working with FSx for Windows
* backups.
*
*
* -
*
* For Amazon FSx for NetApp ONTAP, see Working with FSx for NetApp ONTAP
* backups.
*
*
* -
*
* For Amazon FSx for OpenZFS, see Working with FSx for OpenZFS
* backups.
*
*
*
*
* If a backup with the specified client request token exists and the parameters match, this operation returns the
* description of the existing backup. If a backup with the specified client request token exists and the parameters
* don't match, this operation returns IncompatibleParameterError. If a backup with the specified
* client request token doesn't exist, CreateBackup does the following:
*
*
* -
*
* Creates a new Amazon FSx backup with an assigned ID, and an initial lifecycle state of CREATING.
*
*
* -
*
* Returns the description of the backup.
*
*
*
*
* By using the idempotent operation, you can retry a CreateBackup operation without the risk of
* creating an extra backup. This approach can be useful when an initial call fails in a way that makes it unclear
* whether a backup was created. If you use the same client request token and the initial call created a backup, the
* operation returns a successful result because all the parameters are the same.
*
*
* The CreateBackup operation returns while the backup's lifecycle state is still CREATING
* . You can check the backup creation status by calling the DescribeBackups
* operation, which returns the backup state along with other information.
*
*
* @param createBackupRequest
* The request object for the CreateBackup operation.
* @return Result of the CreateBackup operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws VolumeNotFoundException
* No Amazon FSx volumes were found based upon the supplied parameters.
* @throws BackupInProgressException
* Another backup is already under way. Wait for completion before initiating additional backups of this
* file system.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.CreateBackup
* @see AWS API
* Documentation
*/
@Override
public CreateBackupResult createBackup(CreateBackupRequest request) {
request = beforeClientExecution(request);
return executeCreateBackup(request);
}
@SdkInternalApi
final CreateBackupResult executeCreateBackup(CreateBackupRequest createBackupRequest) {
ExecutionContext executionContext = createExecutionContext(createBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateBackupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createBackupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateBackup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateBackupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Amazon FSx for Lustre data repository association (DRA). A data repository association is a link
* between a directory on the file system and an Amazon S3 bucket or prefix. You can have a maximum of 8 data
* repository associations on a file system. Data repository associations are supported on all FSx for Lustre 2.12
* and 2.15 file systems, excluding scratch_1 deployment type.
*
*
* Each data repository association must have a unique Amazon FSx file system directory and a unique S3 bucket or
* prefix associated with it. You can configure a data repository association for automatic import only, for
* automatic export only, or for both. To learn more about linking a data repository to your file system, see Linking your file
* system to an S3 bucket.
*
*
*
* CreateDataRepositoryAssociation isn't supported on Amazon File Cache resources. To create a DRA on
* Amazon File Cache, use the CreateFileCache operation.
*
*
*
* @param createDataRepositoryAssociationRequest
* @return Result of the CreateDataRepositoryAssociation operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.CreateDataRepositoryAssociation
* @see AWS API Documentation
*/
@Override
public CreateDataRepositoryAssociationResult createDataRepositoryAssociation(CreateDataRepositoryAssociationRequest request) {
request = beforeClientExecution(request);
return executeCreateDataRepositoryAssociation(request);
}
@SdkInternalApi
final CreateDataRepositoryAssociationResult executeCreateDataRepositoryAssociation(
CreateDataRepositoryAssociationRequest createDataRepositoryAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(createDataRepositoryAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDataRepositoryAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createDataRepositoryAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDataRepositoryAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateDataRepositoryAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Amazon FSx for Lustre data repository task. A CreateDataRepositoryTask operation will
* fail if a data repository is not linked to the FSx file system.
*
*
* You use import and export data repository tasks to perform bulk operations between your FSx for Lustre file
* system and its linked data repositories. An example of a data repository task is exporting any data and metadata
* changes, including POSIX metadata, to files, directories, and symbolic links (symlinks) from your FSx file system
* to a linked data repository.
*
*
* You use release data repository tasks to release data from your file system for files that are exported to S3.
* The metadata of released files remains on the file system so users or applications can still access released
* files by reading the files again, which will restore data from Amazon S3 to the FSx for Lustre file system.
*
*
* To learn more about data repository tasks, see Data Repository Tasks.
* To learn more about linking a data repository to your file system, see Linking your file
* system to an S3 bucket.
*
*
* @param createDataRepositoryTaskRequest
* @return Result of the CreateDataRepositoryTask operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws DataRepositoryTaskExecutingException
* An existing data repository task is currently executing on the file system. Wait until the existing task
* has completed, then create the new task.
* @sample AmazonFSx.CreateDataRepositoryTask
* @see AWS
* API Documentation
*/
@Override
public CreateDataRepositoryTaskResult createDataRepositoryTask(CreateDataRepositoryTaskRequest request) {
request = beforeClientExecution(request);
return executeCreateDataRepositoryTask(request);
}
@SdkInternalApi
final CreateDataRepositoryTaskResult executeCreateDataRepositoryTask(CreateDataRepositoryTaskRequest createDataRepositoryTaskRequest) {
ExecutionContext executionContext = createExecutionContext(createDataRepositoryTaskRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDataRepositoryTaskRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createDataRepositoryTaskRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDataRepositoryTask");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateDataRepositoryTaskResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new Amazon File Cache resource.
*
*
* You can use this operation with a client request token in the request that Amazon File Cache uses to ensure
* idempotent creation. If a cache with the specified client request token exists and the parameters match,
* CreateFileCache returns the description of the existing cache. If a cache with the specified client
* request token exists and the parameters don't match, this call returns IncompatibleParameterError.
* If a file cache with the specified client request token doesn't exist, CreateFileCache does the
* following:
*
*
* -
*
* Creates a new, empty Amazon File Cache resourcewith an assigned ID, and an initial lifecycle state of
* CREATING.
*
*
* -
*
* Returns the description of the cache in JSON format.
*
*
*
*
*
* The CreateFileCache call returns while the cache's lifecycle state is still CREATING.
* You can check the cache creation status by calling the DescribeFileCaches
* operation, which returns the cache state along with other information.
*
*
*
* @param createFileCacheRequest
* @return Result of the CreateFileCache operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InvalidNetworkSettingsException
* One or more network settings specified in the request are invalid.
* @throws InvalidPerUnitStorageThroughputException
* An invalid value for PerUnitStorageThroughput was provided. Please create your file system
* again, using a valid value.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws MissingFileCacheConfigurationException
* A cache configuration is required for this operation.
* @sample AmazonFSx.CreateFileCache
* @see AWS API
* Documentation
*/
@Override
public CreateFileCacheResult createFileCache(CreateFileCacheRequest request) {
request = beforeClientExecution(request);
return executeCreateFileCache(request);
}
@SdkInternalApi
final CreateFileCacheResult executeCreateFileCache(CreateFileCacheRequest createFileCacheRequest) {
ExecutionContext executionContext = createExecutionContext(createFileCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateFileCacheRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createFileCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateFileCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateFileCacheResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new, empty Amazon FSx file system. You can create the following supported Amazon FSx file systems using
* the CreateFileSystem API operation:
*
*
* -
*
* Amazon FSx for Lustre
*
*
* -
*
* Amazon FSx for NetApp ONTAP
*
*
* -
*
* Amazon FSx for OpenZFS
*
*
* -
*
* Amazon FSx for Windows File Server
*
*
*
*
* This operation requires a client request token in the request that Amazon FSx uses to ensure idempotent creation.
* This means that calling the operation multiple times with the same client request token has no effect. By using
* the idempotent operation, you can retry a CreateFileSystem operation without the risk of creating an
* extra file system. This approach can be useful when an initial call fails in a way that makes it unclear whether
* a file system was created. Examples are if a transport level timeout occurred, or your connection was reset. If
* you use the same client request token and the initial call created a file system, the client receives success as
* long as the parameters are the same.
*
*
* If a file system with the specified client request token exists and the parameters match,
* CreateFileSystem returns the description of the existing file system. If a file system with the
* specified client request token exists and the parameters don't match, this call returns
* IncompatibleParameterError. If a file system with the specified client request token doesn't exist,
* CreateFileSystem does the following:
*
*
* -
*
* Creates a new, empty Amazon FSx file system with an assigned ID, and an initial lifecycle state of
* CREATING.
*
*
* -
*
* Returns the description of the file system in JSON format.
*
*
*
*
*
* The CreateFileSystem call returns while the file system's lifecycle state is still
* CREATING. You can check the file-system creation status by calling the DescribeFileSystems
* operation, which returns the file system state along with other information.
*
*
*
* @param createFileSystemRequest
* The request object used to create a new Amazon FSx file system.
* @return Result of the CreateFileSystem operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws ActiveDirectoryErrorException
* An Active Directory error.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InvalidImportPathException
* The path provided for data repository import isn't valid.
* @throws InvalidExportPathException
* The path provided for data repository export isn't valid.
* @throws InvalidNetworkSettingsException
* One or more network settings specified in the request are invalid.
* @throws InvalidPerUnitStorageThroughputException
* An invalid value for PerUnitStorageThroughput was provided. Please create your file system
* again, using a valid value.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws MissingFileSystemConfigurationException
* A file system configuration is required for this operation.
* @sample AmazonFSx.CreateFileSystem
* @see AWS API
* Documentation
*/
@Override
public CreateFileSystemResult createFileSystem(CreateFileSystemRequest request) {
request = beforeClientExecution(request);
return executeCreateFileSystem(request);
}
@SdkInternalApi
final CreateFileSystemResult executeCreateFileSystem(CreateFileSystemRequest createFileSystemRequest) {
ExecutionContext executionContext = createExecutionContext(createFileSystemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateFileSystemRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createFileSystemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateFileSystem");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateFileSystemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new Amazon FSx for Lustre, Amazon FSx for Windows File Server, or Amazon FSx for OpenZFS file system
* from an existing Amazon FSx backup.
*
*
* If a file system with the specified client request token exists and the parameters match, this operation returns
* the description of the file system. If a file system with the specified client request token exists but the
* parameters don't match, this call returns IncompatibleParameterError. If a file system with the
* specified client request token doesn't exist, this operation does the following:
*
*
* -
*
* Creates a new Amazon FSx file system from backup with an assigned ID, and an initial lifecycle state of
* CREATING.
*
*
* -
*
* Returns the description of the file system.
*
*
*
*
* Parameters like the Active Directory, default share name, automatic backup, and backup settings default to the
* parameters of the file system that was backed up, unless overridden. You can explicitly supply other settings.
*
*
* By using the idempotent operation, you can retry a CreateFileSystemFromBackup call without the risk
* of creating an extra file system. This approach can be useful when an initial call fails in a way that makes it
* unclear whether a file system was created. Examples are if a transport level timeout occurred, or your connection
* was reset. If you use the same client request token and the initial call created a file system, the client
* receives a success message as long as the parameters are the same.
*
*
*
* The CreateFileSystemFromBackup call returns while the file system's lifecycle state is still
* CREATING. You can check the file-system creation status by calling the DescribeFileSystems
* operation, which returns the file system state along with other information.
*
*
*
* @param createFileSystemFromBackupRequest
* The request object for the CreateFileSystemFromBackup operation.
* @return Result of the CreateFileSystemFromBackup operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws ActiveDirectoryErrorException
* An Active Directory error.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InvalidNetworkSettingsException
* One or more network settings specified in the request are invalid.
* @throws InvalidPerUnitStorageThroughputException
* An invalid value for PerUnitStorageThroughput was provided. Please create your file system
* again, using a valid value.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws BackupNotFoundException
* No Amazon FSx backups were found based upon the supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws MissingFileSystemConfigurationException
* A file system configuration is required for this operation.
* @sample AmazonFSx.CreateFileSystemFromBackup
* @see AWS
* API Documentation
*/
@Override
public CreateFileSystemFromBackupResult createFileSystemFromBackup(CreateFileSystemFromBackupRequest request) {
request = beforeClientExecution(request);
return executeCreateFileSystemFromBackup(request);
}
@SdkInternalApi
final CreateFileSystemFromBackupResult executeCreateFileSystemFromBackup(CreateFileSystemFromBackupRequest createFileSystemFromBackupRequest) {
ExecutionContext executionContext = createExecutionContext(createFileSystemFromBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateFileSystemFromBackupRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createFileSystemFromBackupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateFileSystemFromBackup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateFileSystemFromBackupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a snapshot of an existing Amazon FSx for OpenZFS volume. With snapshots, you can easily undo file changes
* and compare file versions by restoring the volume to a previous version.
*
*
* If a snapshot with the specified client request token exists, and the parameters match, this operation returns
* the description of the existing snapshot. If a snapshot with the specified client request token exists, and the
* parameters don't match, this operation returns IncompatibleParameterError. If a snapshot with the
* specified client request token doesn't exist, CreateSnapshot does the following:
*
*
* -
*
* Creates a new OpenZFS snapshot with an assigned ID, and an initial lifecycle state of CREATING.
*
*
* -
*
* Returns the description of the snapshot.
*
*
*
*
* By using the idempotent operation, you can retry a CreateSnapshot operation without the risk of
* creating an extra snapshot. This approach can be useful when an initial call fails in a way that makes it unclear
* whether a snapshot was created. If you use the same client request token and the initial call created a snapshot,
* the operation returns a successful result because all the parameters are the same.
*
*
* The CreateSnapshot operation returns while the snapshot's lifecycle state is still
* CREATING. You can check the snapshot creation status by calling the DescribeSnapshots
* operation, which returns the snapshot state along with other information.
*
*
* @param createSnapshotRequest
* @return Result of the CreateSnapshot operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws VolumeNotFoundException
* No Amazon FSx volumes were found based upon the supplied parameters.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.CreateSnapshot
* @see AWS API
* Documentation
*/
@Override
public CreateSnapshotResult createSnapshot(CreateSnapshotRequest request) {
request = beforeClientExecution(request);
return executeCreateSnapshot(request);
}
@SdkInternalApi
final CreateSnapshotResult executeCreateSnapshot(CreateSnapshotRequest createSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(createSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateSnapshotRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateSnapshotResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a storage virtual machine (SVM) for an Amazon FSx for ONTAP file system.
*
*
* @param createStorageVirtualMachineRequest
* @return Result of the CreateStorageVirtualMachine operation returned by the service.
* @throws ActiveDirectoryErrorException
* An Active Directory error.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @sample AmazonFSx.CreateStorageVirtualMachine
* @see AWS API Documentation
*/
@Override
public CreateStorageVirtualMachineResult createStorageVirtualMachine(CreateStorageVirtualMachineRequest request) {
request = beforeClientExecution(request);
return executeCreateStorageVirtualMachine(request);
}
@SdkInternalApi
final CreateStorageVirtualMachineResult executeCreateStorageVirtualMachine(CreateStorageVirtualMachineRequest createStorageVirtualMachineRequest) {
ExecutionContext executionContext = createExecutionContext(createStorageVirtualMachineRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateStorageVirtualMachineRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createStorageVirtualMachineRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateStorageVirtualMachine");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateStorageVirtualMachineResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an FSx for ONTAP or Amazon FSx for OpenZFS storage volume.
*
*
* @param createVolumeRequest
* @return Result of the CreateVolume operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws MissingVolumeConfigurationException
* A volume configuration is required for this operation.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws StorageVirtualMachineNotFoundException
* No FSx for ONTAP SVMs were found based upon the supplied parameters.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @sample AmazonFSx.CreateVolume
* @see AWS API
* Documentation
*/
@Override
public CreateVolumeResult createVolume(CreateVolumeRequest request) {
request = beforeClientExecution(request);
return executeCreateVolume(request);
}
@SdkInternalApi
final CreateVolumeResult executeCreateVolume(CreateVolumeRequest createVolumeRequest) {
ExecutionContext executionContext = createExecutionContext(createVolumeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateVolumeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createVolumeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateVolume");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new Amazon FSx for NetApp ONTAP volume from an existing Amazon FSx volume backup.
*
*
* @param createVolumeFromBackupRequest
* @return Result of the CreateVolumeFromBackup operation returned by the service.
* @throws BackupNotFoundException
* No Amazon FSx backups were found based upon the supplied parameters.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws MissingVolumeConfigurationException
* A volume configuration is required for this operation.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws StorageVirtualMachineNotFoundException
* No FSx for ONTAP SVMs were found based upon the supplied parameters.
* @sample AmazonFSx.CreateVolumeFromBackup
* @see AWS API
* Documentation
*/
@Override
public CreateVolumeFromBackupResult createVolumeFromBackup(CreateVolumeFromBackupRequest request) {
request = beforeClientExecution(request);
return executeCreateVolumeFromBackup(request);
}
@SdkInternalApi
final CreateVolumeFromBackupResult executeCreateVolumeFromBackup(CreateVolumeFromBackupRequest createVolumeFromBackupRequest) {
ExecutionContext executionContext = createExecutionContext(createVolumeFromBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateVolumeFromBackupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createVolumeFromBackupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateVolumeFromBackup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateVolumeFromBackupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Amazon FSx backup. After deletion, the backup no longer exists, and its data is gone.
*
*
* The DeleteBackup call returns instantly. The backup won't show up in later
* DescribeBackups calls.
*
*
*
* The data in a deleted backup is also deleted and can't be recovered by any means.
*
*
*
* @param deleteBackupRequest
* The request object for the DeleteBackup operation.
* @return Result of the DeleteBackup operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws BackupInProgressException
* Another backup is already under way. Wait for completion before initiating additional backups of this
* file system.
* @throws BackupNotFoundException
* No Amazon FSx backups were found based upon the supplied parameters.
* @throws BackupRestoringException
* You can't delete a backup while it's being used to restore a file system.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws BackupBeingCopiedException
* You can't delete a backup while it's being copied.
* @sample AmazonFSx.DeleteBackup
* @see AWS API
* Documentation
*/
@Override
public DeleteBackupResult deleteBackup(DeleteBackupRequest request) {
request = beforeClientExecution(request);
return executeDeleteBackup(request);
}
@SdkInternalApi
final DeleteBackupResult executeDeleteBackup(DeleteBackupRequest deleteBackupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteBackupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteBackupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteBackup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteBackupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a data repository association on an Amazon FSx for Lustre file system. Deleting the data repository
* association unlinks the file system from the Amazon S3 bucket. When deleting a data repository association, you
* have the option of deleting the data in the file system that corresponds to the data repository association. Data
* repository associations are supported on all FSx for Lustre 2.12 and 2.15 file systems, excluding
* scratch_1 deployment type.
*
*
* @param deleteDataRepositoryAssociationRequest
* @return Result of the DeleteDataRepositoryAssociation operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws DataRepositoryAssociationNotFoundException
* No data repository associations were found based upon the supplied parameters.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DeleteDataRepositoryAssociation
* @see AWS API Documentation
*/
@Override
public DeleteDataRepositoryAssociationResult deleteDataRepositoryAssociation(DeleteDataRepositoryAssociationRequest request) {
request = beforeClientExecution(request);
return executeDeleteDataRepositoryAssociation(request);
}
@SdkInternalApi
final DeleteDataRepositoryAssociationResult executeDeleteDataRepositoryAssociation(
DeleteDataRepositoryAssociationRequest deleteDataRepositoryAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDataRepositoryAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDataRepositoryAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteDataRepositoryAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDataRepositoryAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteDataRepositoryAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Amazon File Cache resource. After deletion, the cache no longer exists, and its data is gone.
*
*
* The DeleteFileCache operation returns while the cache has the DELETING status. You can
* check the cache deletion status by calling the DescribeFileCaches
* operation, which returns a list of caches in your account. If you pass the cache ID for a deleted cache, the
* DescribeFileCaches operation returns a FileCacheNotFound error.
*
*
*
* The data in a deleted cache is also deleted and can't be recovered by any means.
*
*
*
* @param deleteFileCacheRequest
* @return Result of the DeleteFileCache operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws FileCacheNotFoundException
* No caches were found based upon supplied parameters.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DeleteFileCache
* @see AWS API
* Documentation
*/
@Override
public DeleteFileCacheResult deleteFileCache(DeleteFileCacheRequest request) {
request = beforeClientExecution(request);
return executeDeleteFileCache(request);
}
@SdkInternalApi
final DeleteFileCacheResult executeDeleteFileCache(DeleteFileCacheRequest deleteFileCacheRequest) {
ExecutionContext executionContext = createExecutionContext(deleteFileCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteFileCacheRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteFileCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteFileCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteFileCacheResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a file system. After deletion, the file system no longer exists, and its data is gone. Any existing
* automatic backups and snapshots are also deleted.
*
*
* To delete an Amazon FSx for NetApp ONTAP file system, first delete all the volumes and storage virtual machines
* (SVMs) on the file system. Then provide a FileSystemId value to the DeleFileSystem
* operation.
*
*
* By default, when you delete an Amazon FSx for Windows File Server file system, a final backup is created upon
* deletion. This final backup isn't subject to the file system's retention policy, and must be manually deleted.
*
*
* To delete an Amazon FSx for Lustre file system, first unmount it from every connected
* Amazon EC2 instance, then provide a FileSystemId value to the DeleFileSystem operation.
* By default, Amazon FSx will not take a final backup when the DeleteFileSystem operation is invoked.
* On file systems not linked to an Amazon S3 bucket, set SkipFinalBackup to false to take
* a final backup of the file system you are deleting. Backups cannot be enabled on S3-linked file systems. To
* ensure all of your data is written back to S3 before deleting your file system, you can either monitor for the
* AgeOfOldestQueuedMessage metric to be zero (if using automatic export) or you can run an export data repository
* task. If you have automatic export enabled and want to use an export data repository task, you have to
* disable automatic export before executing the export data repository task.
*
*
* The DeleteFileSystem operation returns while the file system has the DELETING status.
* You can check the file system deletion status by calling the DescribeFileSystems
* operation, which returns a list of file systems in your account. If you pass the file system ID for a deleted
* file system, the DescribeFileSystems operation returns a FileSystemNotFound error.
*
*
*
* If a data repository task is in a PENDING or EXECUTING state, deleting an Amazon FSx
* for Lustre file system will fail with an HTTP status code 400 (Bad Request).
*
*
*
* The data in a deleted file system is also deleted and can't be recovered by any means.
*
*
*
* @param deleteFileSystemRequest
* The request object for DeleteFileSystem operation.
* @return Result of the DeleteFileSystem operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DeleteFileSystem
* @see AWS API
* Documentation
*/
@Override
public DeleteFileSystemResult deleteFileSystem(DeleteFileSystemRequest request) {
request = beforeClientExecution(request);
return executeDeleteFileSystem(request);
}
@SdkInternalApi
final DeleteFileSystemResult executeDeleteFileSystem(DeleteFileSystemRequest deleteFileSystemRequest) {
ExecutionContext executionContext = createExecutionContext(deleteFileSystemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteFileSystemRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteFileSystemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteFileSystem");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteFileSystemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Amazon FSx for OpenZFS snapshot. After deletion, the snapshot no longer exists, and its data is gone.
* Deleting a snapshot doesn't affect snapshots stored in a file system backup.
*
*
* The DeleteSnapshot operation returns instantly. The snapshot appears with the lifecycle status of
* DELETING until the deletion is complete.
*
*
* @param deleteSnapshotRequest
* @return Result of the DeleteSnapshot operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws SnapshotNotFoundException
* No Amazon FSx snapshots were found based on the supplied parameters.
* @sample AmazonFSx.DeleteSnapshot
* @see AWS API
* Documentation
*/
@Override
public DeleteSnapshotResult deleteSnapshot(DeleteSnapshotRequest request) {
request = beforeClientExecution(request);
return executeDeleteSnapshot(request);
}
@SdkInternalApi
final DeleteSnapshotResult executeDeleteSnapshot(DeleteSnapshotRequest deleteSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(deleteSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteSnapshotRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteSnapshotResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an existing Amazon FSx for ONTAP storage virtual machine (SVM). Prior to deleting an SVM, you must delete
* all non-root volumes in the SVM, otherwise the operation will fail.
*
*
* @param deleteStorageVirtualMachineRequest
* @return Result of the DeleteStorageVirtualMachine operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws StorageVirtualMachineNotFoundException
* No FSx for ONTAP SVMs were found based upon the supplied parameters.
* @sample AmazonFSx.DeleteStorageVirtualMachine
* @see AWS API Documentation
*/
@Override
public DeleteStorageVirtualMachineResult deleteStorageVirtualMachine(DeleteStorageVirtualMachineRequest request) {
request = beforeClientExecution(request);
return executeDeleteStorageVirtualMachine(request);
}
@SdkInternalApi
final DeleteStorageVirtualMachineResult executeDeleteStorageVirtualMachine(DeleteStorageVirtualMachineRequest deleteStorageVirtualMachineRequest) {
ExecutionContext executionContext = createExecutionContext(deleteStorageVirtualMachineRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteStorageVirtualMachineRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteStorageVirtualMachineRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteStorageVirtualMachine");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteStorageVirtualMachineResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Amazon FSx for NetApp ONTAP or Amazon FSx for OpenZFS volume.
*
*
* @param deleteVolumeRequest
* @return Result of the DeleteVolume operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws VolumeNotFoundException
* No Amazon FSx volumes were found based upon the supplied parameters.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @sample AmazonFSx.DeleteVolume
* @see AWS API
* Documentation
*/
@Override
public DeleteVolumeResult deleteVolume(DeleteVolumeRequest request) {
request = beforeClientExecution(request);
return executeDeleteVolume(request);
}
@SdkInternalApi
final DeleteVolumeResult executeDeleteVolume(DeleteVolumeRequest deleteVolumeRequest) {
ExecutionContext executionContext = createExecutionContext(deleteVolumeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteVolumeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteVolumeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteVolume");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the description of a specific Amazon FSx backup, if a BackupIds value is provided for that
* backup. Otherwise, it returns all backups owned by your Amazon Web Services account in the Amazon Web Services
* Region of the endpoint that you're calling.
*
*
* When retrieving all backups, you can optionally specify the MaxResults parameter to limit the number
* of backups in a response. If more backups remain, Amazon FSx returns a NextToken value in the
* response. In this case, send a later request with the NextToken request parameter set to the value
* of the NextToken value from the last response.
*
*
* This operation is used in an iterative process to retrieve a list of your backups. DescribeBackups
* is called first without a NextToken value. Then the operation continues to be called with the
* NextToken parameter set to the value of the last NextToken value until a response has
* no NextToken value.
*
*
* When using this operation, keep the following in mind:
*
*
* -
*
* The operation might return fewer than the MaxResults value of backup descriptions while still
* including a NextToken value.
*
*
* -
*
* The order of the backups returned in the response of one DescribeBackups call and the order of the
* backups returned across the responses of a multi-call iteration is unspecified.
*
*
*
*
* @param describeBackupsRequest
* The request object for the DescribeBackups operation.
* @return Result of the DescribeBackups operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws VolumeNotFoundException
* No Amazon FSx volumes were found based upon the supplied parameters.
* @throws BackupNotFoundException
* No Amazon FSx backups were found based upon the supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DescribeBackups
* @see AWS API
* Documentation
*/
@Override
public DescribeBackupsResult describeBackups(DescribeBackupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeBackups(request);
}
@SdkInternalApi
final DescribeBackupsResult executeDescribeBackups(DescribeBackupsRequest describeBackupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeBackupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeBackupsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeBackupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeBackups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeBackupsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the description of specific Amazon FSx for Lustre or Amazon File Cache data repository associations, if
* one or more AssociationIds values are provided in the request, or if filters are used in the
* request. Data repository associations are supported on Amazon File Cache resources and all FSx for Lustre 2.12
* and 2,15 file systems, excluding scratch_1 deployment type.
*
*
* You can use filters to narrow the response to include just data repository associations for specific file systems
* (use the file-system-id filter with the ID of the file system) or caches (use the
* file-cache-id filter with the ID of the cache), or data repository associations for a specific
* repository type (use the data-repository-type filter with a value of S3 or
* NFS). If you don't use filters, the response returns all data repository associations owned by your
* Amazon Web Services account in the Amazon Web Services Region of the endpoint that you're calling.
*
*
* When retrieving all data repository associations, you can paginate the response by using the optional
* MaxResults parameter to limit the number of data repository associations returned in a response. If
* more data repository associations remain, a NextToken value is returned in the response. In this
* case, send a later request with the NextToken request parameter set to the value of
* NextToken from the last response.
*
*
* @param describeDataRepositoryAssociationsRequest
* @return Result of the DescribeDataRepositoryAssociations operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws DataRepositoryAssociationNotFoundException
* No data repository associations were found based upon the supplied parameters.
* @throws InvalidDataRepositoryTypeException
* You have filtered the response to a data repository type that is not supported.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DescribeDataRepositoryAssociations
* @see AWS API Documentation
*/
@Override
public DescribeDataRepositoryAssociationsResult describeDataRepositoryAssociations(DescribeDataRepositoryAssociationsRequest request) {
request = beforeClientExecution(request);
return executeDescribeDataRepositoryAssociations(request);
}
@SdkInternalApi
final DescribeDataRepositoryAssociationsResult executeDescribeDataRepositoryAssociations(
DescribeDataRepositoryAssociationsRequest describeDataRepositoryAssociationsRequest) {
ExecutionContext executionContext = createExecutionContext(describeDataRepositoryAssociationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDataRepositoryAssociationsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeDataRepositoryAssociationsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDataRepositoryAssociations");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeDataRepositoryAssociationsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the description of specific Amazon FSx for Lustre or Amazon File Cache data repository tasks, if one or
* more TaskIds values are provided in the request, or if filters are used in the request. You can use
* filters to narrow the response to include just tasks for specific file systems or caches, or tasks in a specific
* lifecycle state. Otherwise, it returns all data repository tasks owned by your Amazon Web Services account in the
* Amazon Web Services Region of the endpoint that you're calling.
*
*
* When retrieving all tasks, you can paginate the response by using the optional MaxResults parameter
* to limit the number of tasks returned in a response. If more tasks remain, a NextToken value is
* returned in the response. In this case, send a later request with the NextToken request parameter
* set to the value of NextToken from the last response.
*
*
* @param describeDataRepositoryTasksRequest
* @return Result of the DescribeDataRepositoryTasks operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws DataRepositoryTaskNotFoundException
* The data repository task or tasks you specified could not be found.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DescribeDataRepositoryTasks
* @see AWS API Documentation
*/
@Override
public DescribeDataRepositoryTasksResult describeDataRepositoryTasks(DescribeDataRepositoryTasksRequest request) {
request = beforeClientExecution(request);
return executeDescribeDataRepositoryTasks(request);
}
@SdkInternalApi
final DescribeDataRepositoryTasksResult executeDescribeDataRepositoryTasks(DescribeDataRepositoryTasksRequest describeDataRepositoryTasksRequest) {
ExecutionContext executionContext = createExecutionContext(describeDataRepositoryTasksRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDataRepositoryTasksRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeDataRepositoryTasksRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDataRepositoryTasks");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeDataRepositoryTasksResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the description of a specific Amazon File Cache resource, if a FileCacheIds value is
* provided for that cache. Otherwise, it returns descriptions of all caches owned by your Amazon Web Services
* account in the Amazon Web Services Region of the endpoint that you're calling.
*
*
* When retrieving all cache descriptions, you can optionally specify the MaxResults parameter to limit
* the number of descriptions in a response. If more cache descriptions remain, the operation returns a
* NextToken value in the response. In this case, send a later request with the NextToken
* request parameter set to the value of NextToken from the last response.
*
*
* This operation is used in an iterative process to retrieve a list of your cache descriptions.
* DescribeFileCaches is called first without a NextTokenvalue. Then the operation
* continues to be called with the NextToken parameter set to the value of the last
* NextToken value until a response has no NextToken.
*
*
* When using this operation, keep the following in mind:
*
*
* -
*
* The implementation might return fewer than MaxResults cache descriptions while still including a
* NextToken value.
*
*
* -
*
* The order of caches returned in the response of one DescribeFileCaches call and the order of caches
* returned across the responses of a multicall iteration is unspecified.
*
*
*
*
* @param describeFileCachesRequest
* @return Result of the DescribeFileCaches operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileCacheNotFoundException
* No caches were found based upon supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DescribeFileCaches
* @see AWS API
* Documentation
*/
@Override
public DescribeFileCachesResult describeFileCaches(DescribeFileCachesRequest request) {
request = beforeClientExecution(request);
return executeDescribeFileCaches(request);
}
@SdkInternalApi
final DescribeFileCachesResult executeDescribeFileCaches(DescribeFileCachesRequest describeFileCachesRequest) {
ExecutionContext executionContext = createExecutionContext(describeFileCachesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeFileCachesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeFileCachesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeFileCaches");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeFileCachesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the DNS aliases that are associated with the specified Amazon FSx for Windows File Server file system. A
* history of all DNS aliases that have been associated with and disassociated from the file system is available in
* the list of AdministrativeAction provided in the DescribeFileSystems operation response.
*
*
* @param describeFileSystemAliasesRequest
* The request object for DescribeFileSystemAliases operation.
* @return Result of the DescribeFileSystemAliases operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DescribeFileSystemAliases
* @see AWS
* API Documentation
*/
@Override
public DescribeFileSystemAliasesResult describeFileSystemAliases(DescribeFileSystemAliasesRequest request) {
request = beforeClientExecution(request);
return executeDescribeFileSystemAliases(request);
}
@SdkInternalApi
final DescribeFileSystemAliasesResult executeDescribeFileSystemAliases(DescribeFileSystemAliasesRequest describeFileSystemAliasesRequest) {
ExecutionContext executionContext = createExecutionContext(describeFileSystemAliasesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeFileSystemAliasesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeFileSystemAliasesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeFileSystemAliases");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeFileSystemAliasesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the description of specific Amazon FSx file systems, if a FileSystemIds value is provided
* for that file system. Otherwise, it returns descriptions of all file systems owned by your Amazon Web Services
* account in the Amazon Web Services Region of the endpoint that you're calling.
*
*
* When retrieving all file system descriptions, you can optionally specify the MaxResults parameter to
* limit the number of descriptions in a response. If more file system descriptions remain, Amazon FSx returns a
* NextToken value in the response. In this case, send a later request with the NextToken
* request parameter set to the value of NextToken from the last response.
*
*
* This operation is used in an iterative process to retrieve a list of your file system descriptions.
* DescribeFileSystems is called first without a NextTokenvalue. Then the operation
* continues to be called with the NextToken parameter set to the value of the last
* NextToken value until a response has no NextToken.
*
*
* When using this operation, keep the following in mind:
*
*
* -
*
* The implementation might return fewer than MaxResults file system descriptions while still including
* a NextToken value.
*
*
* -
*
* The order of file systems returned in the response of one DescribeFileSystems call and the order of
* file systems returned across the responses of a multicall iteration is unspecified.
*
*
*
*
* @param describeFileSystemsRequest
* The request object for DescribeFileSystems operation.
* @return Result of the DescribeFileSystems operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DescribeFileSystems
* @see AWS API
* Documentation
*/
@Override
public DescribeFileSystemsResult describeFileSystems(DescribeFileSystemsRequest request) {
request = beforeClientExecution(request);
return executeDescribeFileSystems(request);
}
@SdkInternalApi
final DescribeFileSystemsResult executeDescribeFileSystems(DescribeFileSystemsRequest describeFileSystemsRequest) {
ExecutionContext executionContext = createExecutionContext(describeFileSystemsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeFileSystemsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeFileSystemsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeFileSystems");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeFileSystemsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Indicates whether participant accounts in your organization can create Amazon FSx for NetApp ONTAP Multi-AZ file
* systems in subnets that are shared by a virtual private cloud (VPC) owner. For more information, see Creating FSx for ONTAP file systems in shared subnets.
*
*
* @param describeSharedVpcConfigurationRequest
* @return Result of the DescribeSharedVpcConfiguration operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DescribeSharedVpcConfiguration
* @see AWS API Documentation
*/
@Override
public DescribeSharedVpcConfigurationResult describeSharedVpcConfiguration(DescribeSharedVpcConfigurationRequest request) {
request = beforeClientExecution(request);
return executeDescribeSharedVpcConfiguration(request);
}
@SdkInternalApi
final DescribeSharedVpcConfigurationResult executeDescribeSharedVpcConfiguration(DescribeSharedVpcConfigurationRequest describeSharedVpcConfigurationRequest) {
ExecutionContext executionContext = createExecutionContext(describeSharedVpcConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeSharedVpcConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeSharedVpcConfigurationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeSharedVpcConfiguration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeSharedVpcConfigurationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the description of specific Amazon FSx for OpenZFS snapshots, if a SnapshotIds value is
* provided. Otherwise, this operation returns all snapshots owned by your Amazon Web Services account in the Amazon
* Web Services Region of the endpoint that you're calling.
*
*
* When retrieving all snapshots, you can optionally specify the MaxResults parameter to limit the
* number of snapshots in a response. If more backups remain, Amazon FSx returns a NextToken value in
* the response. In this case, send a later request with the NextToken request parameter set to the
* value of NextToken from the last response.
*
*
* Use this operation in an iterative process to retrieve a list of your snapshots. DescribeSnapshots
* is called first without a NextToken value. Then the operation continues to be called with the
* NextToken parameter set to the value of the last NextToken value until a response has
* no NextToken value.
*
*
* When using this operation, keep the following in mind:
*
*
* -
*
* The operation might return fewer than the MaxResults value of snapshot descriptions while still
* including a NextToken value.
*
*
* -
*
* The order of snapshots returned in the response of one DescribeSnapshots call and the order of
* backups returned across the responses of a multi-call iteration is unspecified.
*
*
*
*
* @param describeSnapshotsRequest
* @return Result of the DescribeSnapshots operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws SnapshotNotFoundException
* No Amazon FSx snapshots were found based on the supplied parameters.
* @sample AmazonFSx.DescribeSnapshots
* @see AWS API
* Documentation
*/
@Override
public DescribeSnapshotsResult describeSnapshots(DescribeSnapshotsRequest request) {
request = beforeClientExecution(request);
return executeDescribeSnapshots(request);
}
@SdkInternalApi
final DescribeSnapshotsResult executeDescribeSnapshots(DescribeSnapshotsRequest describeSnapshotsRequest) {
ExecutionContext executionContext = createExecutionContext(describeSnapshotsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeSnapshotsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeSnapshotsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeSnapshots");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeSnapshotsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes one or more Amazon FSx for NetApp ONTAP storage virtual machines (SVMs).
*
*
* @param describeStorageVirtualMachinesRequest
* @return Result of the DescribeStorageVirtualMachines operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws StorageVirtualMachineNotFoundException
* No FSx for ONTAP SVMs were found based upon the supplied parameters.
* @sample AmazonFSx.DescribeStorageVirtualMachines
* @see AWS API Documentation
*/
@Override
public DescribeStorageVirtualMachinesResult describeStorageVirtualMachines(DescribeStorageVirtualMachinesRequest request) {
request = beforeClientExecution(request);
return executeDescribeStorageVirtualMachines(request);
}
@SdkInternalApi
final DescribeStorageVirtualMachinesResult executeDescribeStorageVirtualMachines(DescribeStorageVirtualMachinesRequest describeStorageVirtualMachinesRequest) {
ExecutionContext executionContext = createExecutionContext(describeStorageVirtualMachinesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeStorageVirtualMachinesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeStorageVirtualMachinesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeStorageVirtualMachines");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeStorageVirtualMachinesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes one or more Amazon FSx for NetApp ONTAP or Amazon FSx for OpenZFS volumes.
*
*
* @param describeVolumesRequest
* @return Result of the DescribeVolumes operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws VolumeNotFoundException
* No Amazon FSx volumes were found based upon the supplied parameters.
* @sample AmazonFSx.DescribeVolumes
* @see AWS API
* Documentation
*/
@Override
public DescribeVolumesResult describeVolumes(DescribeVolumesRequest request) {
request = beforeClientExecution(request);
return executeDescribeVolumes(request);
}
@SdkInternalApi
final DescribeVolumesResult executeDescribeVolumes(DescribeVolumesRequest describeVolumesRequest) {
ExecutionContext executionContext = createExecutionContext(describeVolumesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeVolumesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeVolumesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeVolumes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeVolumesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Use this action to disassociate, or remove, one or more Domain Name Service (DNS) aliases from an Amazon FSx for
* Windows File Server file system. If you attempt to disassociate a DNS alias that is not associated with the file
* system, Amazon FSx responds with an HTTP status code 400 (Bad Request). For more information, see Working with DNS
* Aliases.
*
*
* The system generated response showing the DNS aliases that Amazon FSx is attempting to disassociate from the file
* system. Use the API operation to monitor the status of the aliases Amazon FSx is disassociating with the file
* system.
*
*
* @param disassociateFileSystemAliasesRequest
* The request object of DNS aliases to disassociate from an Amazon FSx for Windows File Server file system.
* @return Result of the DisassociateFileSystemAliases operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.DisassociateFileSystemAliases
* @see AWS API Documentation
*/
@Override
public DisassociateFileSystemAliasesResult disassociateFileSystemAliases(DisassociateFileSystemAliasesRequest request) {
request = beforeClientExecution(request);
return executeDisassociateFileSystemAliases(request);
}
@SdkInternalApi
final DisassociateFileSystemAliasesResult executeDisassociateFileSystemAliases(DisassociateFileSystemAliasesRequest disassociateFileSystemAliasesRequest) {
ExecutionContext executionContext = createExecutionContext(disassociateFileSystemAliasesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisassociateFileSystemAliasesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(disassociateFileSystemAliasesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisassociateFileSystemAliases");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DisassociateFileSystemAliasesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists tags for Amazon FSx resources.
*
*
* When retrieving all tags, you can optionally specify the MaxResults parameter to limit the number of
* tags in a response. If more tags remain, Amazon FSx returns a NextToken value in the response. In
* this case, send a later request with the NextToken request parameter set to the value of
* NextToken from the last response.
*
*
* This action is used in an iterative process to retrieve a list of your tags. ListTagsForResource is
* called first without a NextTokenvalue. Then the action continues to be called with the
* NextToken parameter set to the value of the last NextToken value until a response has
* no NextToken.
*
*
* When using this action, keep the following in mind:
*
*
* -
*
* The implementation might return fewer than MaxResults file system descriptions while still including
* a NextToken value.
*
*
* -
*
* The order of tags returned in the response of one ListTagsForResource call and the order of tags
* returned across the responses of a multi-call iteration is unspecified.
*
*
*
*
* @param listTagsForResourceRequest
* The request object for ListTagsForResource operation.
* @return Result of the ListTagsForResource operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws ResourceNotFoundException
* The resource specified by the Amazon Resource Name (ARN) can't be found.
* @throws NotServiceResourceErrorException
* The resource specified for the tagging operation is not a resource type owned by Amazon FSx. Use the API
* of the relevant service to perform the operation.
* @throws ResourceDoesNotSupportTaggingException
* The resource specified does not support tagging.
* @sample AmazonFSx.ListTagsForResource
* @see AWS API
* Documentation
*/
@Override
public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) {
request = beforeClientExecution(request);
return executeListTagsForResource(request);
}
@SdkInternalApi
final ListTagsForResourceResult executeListTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest) {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTagsForResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTagsForResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Releases the file system lock from an Amazon FSx for OpenZFS file system.
*
*
* @param releaseFileSystemNfsV3LocksRequest
* @return Result of the ReleaseFileSystemNfsV3Locks operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.ReleaseFileSystemNfsV3Locks
* @see AWS API Documentation
*/
@Override
public ReleaseFileSystemNfsV3LocksResult releaseFileSystemNfsV3Locks(ReleaseFileSystemNfsV3LocksRequest request) {
request = beforeClientExecution(request);
return executeReleaseFileSystemNfsV3Locks(request);
}
@SdkInternalApi
final ReleaseFileSystemNfsV3LocksResult executeReleaseFileSystemNfsV3Locks(ReleaseFileSystemNfsV3LocksRequest releaseFileSystemNfsV3LocksRequest) {
ExecutionContext executionContext = createExecutionContext(releaseFileSystemNfsV3LocksRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ReleaseFileSystemNfsV3LocksRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(releaseFileSystemNfsV3LocksRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ReleaseFileSystemNfsV3Locks");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ReleaseFileSystemNfsV3LocksResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns an Amazon FSx for OpenZFS volume to the state saved by the specified snapshot.
*
*
* @param restoreVolumeFromSnapshotRequest
* @return Result of the RestoreVolumeFromSnapshot operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws VolumeNotFoundException
* No Amazon FSx volumes were found based upon the supplied parameters.
* @sample AmazonFSx.RestoreVolumeFromSnapshot
* @see AWS
* API Documentation
*/
@Override
public RestoreVolumeFromSnapshotResult restoreVolumeFromSnapshot(RestoreVolumeFromSnapshotRequest request) {
request = beforeClientExecution(request);
return executeRestoreVolumeFromSnapshot(request);
}
@SdkInternalApi
final RestoreVolumeFromSnapshotResult executeRestoreVolumeFromSnapshot(RestoreVolumeFromSnapshotRequest restoreVolumeFromSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(restoreVolumeFromSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RestoreVolumeFromSnapshotRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(restoreVolumeFromSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RestoreVolumeFromSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RestoreVolumeFromSnapshotResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* After performing steps to repair the Active Directory configuration of an FSx for Windows File Server file
* system, use this action to initiate the process of Amazon FSx attempting to reconnect to the file system.
*
*
* @param startMisconfiguredStateRecoveryRequest
* @return Result of the StartMisconfiguredStateRecovery operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.StartMisconfiguredStateRecovery
* @see AWS API Documentation
*/
@Override
public StartMisconfiguredStateRecoveryResult startMisconfiguredStateRecovery(StartMisconfiguredStateRecoveryRequest request) {
request = beforeClientExecution(request);
return executeStartMisconfiguredStateRecovery(request);
}
@SdkInternalApi
final StartMisconfiguredStateRecoveryResult executeStartMisconfiguredStateRecovery(
StartMisconfiguredStateRecoveryRequest startMisconfiguredStateRecoveryRequest) {
ExecutionContext executionContext = createExecutionContext(startMisconfiguredStateRecoveryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartMisconfiguredStateRecoveryRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(startMisconfiguredStateRecoveryRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartMisconfiguredStateRecovery");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new StartMisconfiguredStateRecoveryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Tags an Amazon FSx resource.
*
*
* @param tagResourceRequest
* The request object for the TagResource operation.
* @return Result of the TagResource operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws ResourceNotFoundException
* The resource specified by the Amazon Resource Name (ARN) can't be found.
* @throws NotServiceResourceErrorException
* The resource specified for the tagging operation is not a resource type owned by Amazon FSx. Use the API
* of the relevant service to perform the operation.
* @throws ResourceDoesNotSupportTaggingException
* The resource specified does not support tagging.
* @sample AmazonFSx.TagResource
* @see AWS API
* Documentation
*/
@Override
public TagResourceResult tagResource(TagResourceRequest request) {
request = beforeClientExecution(request);
return executeTagResource(request);
}
@SdkInternalApi
final TagResourceResult executeTagResource(TagResourceRequest tagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(tagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(tagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* This action removes a tag from an Amazon FSx resource.
*
*
* @param untagResourceRequest
* The request object for UntagResource action.
* @return Result of the UntagResource operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws ResourceNotFoundException
* The resource specified by the Amazon Resource Name (ARN) can't be found.
* @throws NotServiceResourceErrorException
* The resource specified for the tagging operation is not a resource type owned by Amazon FSx. Use the API
* of the relevant service to perform the operation.
* @throws ResourceDoesNotSupportTaggingException
* The resource specified does not support tagging.
* @sample AmazonFSx.UntagResource
* @see AWS API
* Documentation
*/
@Override
public UntagResourceResult untagResource(UntagResourceRequest request) {
request = beforeClientExecution(request);
return executeUntagResource(request);
}
@SdkInternalApi
final UntagResourceResult executeUntagResource(UntagResourceRequest untagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(untagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(untagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UntagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the configuration of an existing data repository association on an Amazon FSx for Lustre file system.
* Data repository associations are supported on all FSx for Lustre 2.12 and 2.15 file systems, excluding
* scratch_1 deployment type.
*
*
* @param updateDataRepositoryAssociationRequest
* @return Result of the UpdateDataRepositoryAssociation operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws DataRepositoryAssociationNotFoundException
* No data repository associations were found based upon the supplied parameters.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.UpdateDataRepositoryAssociation
* @see AWS API Documentation
*/
@Override
public UpdateDataRepositoryAssociationResult updateDataRepositoryAssociation(UpdateDataRepositoryAssociationRequest request) {
request = beforeClientExecution(request);
return executeUpdateDataRepositoryAssociation(request);
}
@SdkInternalApi
final UpdateDataRepositoryAssociationResult executeUpdateDataRepositoryAssociation(
UpdateDataRepositoryAssociationRequest updateDataRepositoryAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(updateDataRepositoryAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateDataRepositoryAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateDataRepositoryAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateDataRepositoryAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateDataRepositoryAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the configuration of an existing Amazon File Cache resource. You can update multiple properties in a
* single request.
*
*
* @param updateFileCacheRequest
* @return Result of the UpdateFileCache operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws FileCacheNotFoundException
* No caches were found based upon supplied parameters.
* @throws MissingFileCacheConfigurationException
* A cache configuration is required for this operation.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @sample AmazonFSx.UpdateFileCache
* @see AWS API
* Documentation
*/
@Override
public UpdateFileCacheResult updateFileCache(UpdateFileCacheRequest request) {
request = beforeClientExecution(request);
return executeUpdateFileCache(request);
}
@SdkInternalApi
final UpdateFileCacheResult executeUpdateFileCache(UpdateFileCacheRequest updateFileCacheRequest) {
ExecutionContext executionContext = createExecutionContext(updateFileCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateFileCacheRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateFileCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateFileCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateFileCacheResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Use this operation to update the configuration of an existing Amazon FSx file system. You can update multiple
* properties in a single request.
*
*
* For FSx for Windows File Server file systems, you can update the following properties:
*
*
* -
*
* AuditLogConfiguration
*
*
* -
*
* AutomaticBackupRetentionDays
*
*
* -
*
* DailyAutomaticBackupStartTime
*
*
* -
*
* SelfManagedActiveDirectoryConfiguration
*
*
* -
*
* StorageCapacity
*
*
* -
*
* StorageType
*
*
* -
*
* ThroughputCapacity
*
*
* -
*
* DiskIopsConfiguration
*
*
* -
*
* WeeklyMaintenanceStartTime
*
*
*
*
* For FSx for Lustre file systems, you can update the following properties:
*
*
* -
*
* AutoImportPolicy
*
*
* -
*
* AutomaticBackupRetentionDays
*
*
* -
*
* DailyAutomaticBackupStartTime
*
*
* -
*
* DataCompressionType
*
*
* -
*
* LogConfiguration
*
*
* -
*
* LustreRootSquashConfiguration
*
*
* -
*
* PerUnitStorageThroughput
*
*
* -
*
* StorageCapacity
*
*
* -
*
* WeeklyMaintenanceStartTime
*
*
*
*
* For FSx for ONTAP file systems, you can update the following properties:
*
*
* -
*
* AddRouteTableIds
*
*
* -
*
* AutomaticBackupRetentionDays
*
*
* -
*
* DailyAutomaticBackupStartTime
*
*
* -
*
* DiskIopsConfiguration
*
*
* -
*
* FsxAdminPassword
*
*
* -
*
* HAPairs
*
*
* -
*
* RemoveRouteTableIds
*
*
* -
*
* StorageCapacity
*
*
* -
*
* ThroughputCapacity
*
*
* -
*
* ThroughputCapacityPerHAPair
*
*
* -
*
* WeeklyMaintenanceStartTime
*
*
*
*
* For FSx for OpenZFS file systems, you can update the following properties:
*
*
* -
*
* AddRouteTableIds
*
*
* -
*
* AutomaticBackupRetentionDays
*
*
* -
*
* CopyTagsToBackups
*
*
* -
*
* CopyTagsToVolumes
*
*
* -
*
* DailyAutomaticBackupStartTime
*
*
* -
*
* DiskIopsConfiguration
*
*
* -
*
* RemoveRouteTableIds
*
*
* -
*
* StorageCapacity
*
*
* -
*
* ThroughputCapacity
*
*
* -
*
* WeeklyMaintenanceStartTime
*
*
*
*
* @param updateFileSystemRequest
* The request object for the UpdateFileSystem operation.
* @return Result of the UpdateFileSystem operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InvalidNetworkSettingsException
* One or more network settings specified in the request are invalid.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws FileSystemNotFoundException
* No Amazon FSx file systems were found based upon supplied parameters.
* @throws MissingFileSystemConfigurationException
* A file system configuration is required for this operation.
* @throws ServiceLimitExceededException
* An error indicating that a particular service limit was exceeded. You can increase some service limits by
* contacting Amazon Web Services Support.
* @sample AmazonFSx.UpdateFileSystem
* @see AWS API
* Documentation
*/
@Override
public UpdateFileSystemResult updateFileSystem(UpdateFileSystemRequest request) {
request = beforeClientExecution(request);
return executeUpdateFileSystem(request);
}
@SdkInternalApi
final UpdateFileSystemResult executeUpdateFileSystem(UpdateFileSystemRequest updateFileSystemRequest) {
ExecutionContext executionContext = createExecutionContext(updateFileSystemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateFileSystemRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateFileSystemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateFileSystem");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateFileSystemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Configures whether participant accounts in your organization can create Amazon FSx for NetApp ONTAP Multi-AZ file
* systems in subnets that are shared by a virtual private cloud (VPC) owner. For more information, see the Amazon FSx for NetApp ONTAP User
* Guide.
*
*
*
* We strongly recommend that participant-created Multi-AZ file systems in the shared VPC are deleted before you
* disable this feature. Once the feature is disabled, these file systems will enter a MISCONFIGURED
* state and behave like Single-AZ file systems. For more information, see Important
* considerations before disabling shared VPC support for Multi-AZ file systems.
*
*
*
* @param updateSharedVpcConfigurationRequest
* @return Result of the UpdateSharedVpcConfiguration operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.UpdateSharedVpcConfiguration
* @see AWS API Documentation
*/
@Override
public UpdateSharedVpcConfigurationResult updateSharedVpcConfiguration(UpdateSharedVpcConfigurationRequest request) {
request = beforeClientExecution(request);
return executeUpdateSharedVpcConfiguration(request);
}
@SdkInternalApi
final UpdateSharedVpcConfigurationResult executeUpdateSharedVpcConfiguration(UpdateSharedVpcConfigurationRequest updateSharedVpcConfigurationRequest) {
ExecutionContext executionContext = createExecutionContext(updateSharedVpcConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateSharedVpcConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateSharedVpcConfigurationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateSharedVpcConfiguration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateSharedVpcConfigurationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the name of an Amazon FSx for OpenZFS snapshot.
*
*
* @param updateSnapshotRequest
* @return Result of the UpdateSnapshot operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws SnapshotNotFoundException
* No Amazon FSx snapshots were found based on the supplied parameters.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @sample AmazonFSx.UpdateSnapshot
* @see AWS API
* Documentation
*/
@Override
public UpdateSnapshotResult updateSnapshot(UpdateSnapshotRequest request) {
request = beforeClientExecution(request);
return executeUpdateSnapshot(request);
}
@SdkInternalApi
final UpdateSnapshotResult executeUpdateSnapshot(UpdateSnapshotRequest updateSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(updateSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateSnapshotRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateSnapshotResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an FSx for ONTAP storage virtual machine (SVM).
*
*
* @param updateStorageVirtualMachineRequest
* @return Result of the UpdateStorageVirtualMachine operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws StorageVirtualMachineNotFoundException
* No FSx for ONTAP SVMs were found based upon the supplied parameters.
* @throws UnsupportedOperationException
* The requested operation is not supported for this resource or API.
* @sample AmazonFSx.UpdateStorageVirtualMachine
* @see AWS API Documentation
*/
@Override
public UpdateStorageVirtualMachineResult updateStorageVirtualMachine(UpdateStorageVirtualMachineRequest request) {
request = beforeClientExecution(request);
return executeUpdateStorageVirtualMachine(request);
}
@SdkInternalApi
final UpdateStorageVirtualMachineResult executeUpdateStorageVirtualMachine(UpdateStorageVirtualMachineRequest updateStorageVirtualMachineRequest) {
ExecutionContext executionContext = createExecutionContext(updateStorageVirtualMachineRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateStorageVirtualMachineRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateStorageVirtualMachineRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateStorageVirtualMachine");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateStorageVirtualMachineResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the configuration of an Amazon FSx for NetApp ONTAP or Amazon FSx for OpenZFS volume.
*
*
* @param updateVolumeRequest
* @return Result of the UpdateVolume operation returned by the service.
* @throws BadRequestException
* A generic error indicating a failure with a client request.
* @throws IncompatibleParameterErrorException
* The error returned when a second request is received with the same client request token but different
* parameters settings. A client request token should always uniquely identify a single request.
* @throws InternalServerErrorException
* A generic error indicating a server-side failure.
* @throws MissingVolumeConfigurationException
* A volume configuration is required for this operation.
* @throws VolumeNotFoundException
* No Amazon FSx volumes were found based upon the supplied parameters.
* @sample AmazonFSx.UpdateVolume
* @see AWS API
* Documentation
*/
@Override
public UpdateVolumeResult updateVolume(UpdateVolumeRequest request) {
request = beforeClientExecution(request);
return executeUpdateVolume(request);
}
@SdkInternalApi
final UpdateVolumeResult executeUpdateVolume(UpdateVolumeRequest updateVolumeRequest) {
ExecutionContext executionContext = createExecutionContext(updateVolumeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateVolumeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateVolumeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "FSx");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateVolume");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
@Override
public void shutdown() {
super.shutdown();
}
}