com.amazonaws.services.storagegateway.AWSStorageGatewayClient Maven / Gradle / Ivy
/*
* Copyright 2018-2023 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.storagegateway;
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.storagegateway.AWSStorageGatewayClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.storagegateway.model.*;
import com.amazonaws.services.storagegateway.model.transform.*;
/**
* Client for accessing AWS Storage Gateway. All service calls made using this client are blocking, and will not return
* until the service call completes.
*
* Storage Gateway Service
*
* Storage Gateway is the service that connects an on-premises software appliance with cloud-based storage to provide
* seamless and secure integration between an organization's on-premises IT environment and the Amazon Web Services
* storage infrastructure. The service enables you to securely upload data to the Amazon Web Services Cloud for cost
* effective backup and rapid disaster recovery.
*
*
* Use the following links to get started using the Storage Gateway Service API Reference:
*
*
* -
*
* Storage Gateway required request headers: Describes the required headers that you must send with every POST
* request to Storage Gateway.
*
*
* -
*
* Signing requests: Storage Gateway requires that you authenticate every request you send; this topic describes
* how sign such a request.
*
*
* -
*
*
* Error responses: Provides reference information about Storage Gateway errors.
*
*
* -
*
* Operations in Storage
* Gateway: Contains detailed descriptions of all Storage Gateway operations, their request parameters, response
* elements, possible errors, and examples of requests and responses.
*
*
* -
*
* Storage Gateway endpoints and quotas: Provides a
* list of each Amazon Web Services Region and the endpoints available for use with Storage Gateway.
*
*
*
*
*
* Storage Gateway resource IDs are in uppercase. When you use these resource IDs with the Amazon EC2 API, EC2 expects
* resource IDs in lowercase. You must change your resource ID to lowercase to use it with the EC2 API. For example, in
* Storage Gateway the ID for a volume might be vol-AA22BB012345DAF670. When you use this ID with the EC2
* API, you must change it to vol-aa22bb012345daf670. Otherwise, the EC2 API might not behave as expected.
*
*
*
* IDs for Storage Gateway volumes and Amazon EBS snapshots created from gateway volumes are changing to a longer
* format. Starting in December 2016, all new volumes and snapshots will be created with a 17-character string. Starting
* in April 2016, you will be able to use these longer IDs so you can test your systems with the new format. For more
* information, see Longer EC2 and EBS resource IDs.
*
*
* For example, a volume Amazon Resource Name (ARN) with the longer volume ID format looks like the following:
*
*
* arn:aws:storagegateway:us-west-2:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABBCCDDEEFFG.
*
*
* A snapshot ID with the longer ID format looks like the following: snap-78e226633445566ee.
*
*
* For more information, see Announcement: Heads-up – Longer
* Storage Gateway volume and snapshot IDs coming in 2016.
*
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSStorageGatewayClient extends AmazonWebServiceClient implements AWSStorageGateway {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AWSStorageGateway.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "storagegateway";
/** 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("InvalidGatewayRequestException").withExceptionUnmarshaller(
com.amazonaws.services.storagegateway.model.transform.InvalidGatewayRequestExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServiceUnavailableError").withExceptionUnmarshaller(
com.amazonaws.services.storagegateway.model.transform.ServiceUnavailableErrorExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InternalServerError").withExceptionUnmarshaller(
com.amazonaws.services.storagegateway.model.transform.InternalServerErrorExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.storagegateway.model.AWSStorageGatewayException.class));
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway. A credentials provider chain will be
* used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AWSStorageGatewayClientBuilder#defaultClient()}
*/
@Deprecated
public AWSStorageGatewayClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway. A credentials provider chain will be
* used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to AWS Storage Gateway (ex: proxy
* settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AWSStorageGatewayClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSStorageGatewayClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway using the specified AWS account
* credentials.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @deprecated use {@link AWSStorageGatewayClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AWSStorageGatewayClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
public AWSStorageGatewayClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway using the specified AWS account
* credentials and client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to AWS Storage Gateway (ex: proxy
* settings, retry counts, etc.).
* @deprecated use {@link AWSStorageGatewayClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSStorageGatewayClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSStorageGatewayClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway using the specified AWS account
* credentials provider.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @deprecated use {@link AWSStorageGatewayClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AWSStorageGatewayClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway using the specified AWS account
* credentials provider and client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to AWS Storage Gateway (ex: proxy
* settings, retry counts, etc.).
* @deprecated use {@link AWSStorageGatewayClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSStorageGatewayClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSStorageGatewayClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway using the specified AWS account
* credentials provider, client configuration options, and request metric collector.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to AWS Storage Gateway (ex: proxy
* settings, retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
* @deprecated use {@link AWSStorageGatewayClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSStorageGatewayClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AWSStorageGatewayClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AWSStorageGatewayClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
public static AWSStorageGatewayClientBuilder builder() {
return AWSStorageGatewayClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway 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.
*/
AWSStorageGatewayClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on AWS Storage Gateway 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.
*/
AWSStorageGatewayClient(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("https://storagegateway.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/storagegateway/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/storagegateway/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Activates the gateway you previously deployed on your host. In the activation process, you specify information
* such as the Amazon Web Services Region that you want to use for storing snapshots or tapes, the time zone for
* scheduled snapshots the gateway snapshot schedule window, an activation key, and a name for your gateway. The
* activation process also associates your gateway with your account. For more information, see
* UpdateGatewayInformation.
*
*
*
* You must turn on the gateway VM before you can activate your gateway.
*
*
*
* @param activateGatewayRequest
* A JSON object containing one or more of the following fields:
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* @return Result of the ActivateGateway operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ActivateGateway
* @see AWS
* API Documentation
*/
@Override
public ActivateGatewayResult activateGateway(ActivateGatewayRequest request) {
request = beforeClientExecution(request);
return executeActivateGateway(request);
}
@SdkInternalApi
final ActivateGatewayResult executeActivateGateway(ActivateGatewayRequest activateGatewayRequest) {
ExecutionContext executionContext = createExecutionContext(activateGatewayRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ActivateGatewayRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(activateGatewayRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ActivateGateway");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ActivateGatewayResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Configures one or more gateway local disks as cache for a gateway. This operation is only supported in the cached
* volume, tape, and file gateway type (see How Storage
* Gateway works (architecture).
*
*
* In the request, you specify the gateway Amazon Resource Name (ARN) to which you want to add cache, and one or
* more disk IDs that you want to configure as cache.
*
*
* @param addCacheRequest
* @return Result of the AddCache operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.AddCache
* @see AWS API
* Documentation
*/
@Override
public AddCacheResult addCache(AddCacheRequest request) {
request = beforeClientExecution(request);
return executeAddCache(request);
}
@SdkInternalApi
final AddCacheResult executeAddCache(AddCacheRequest addCacheRequest) {
ExecutionContext executionContext = createExecutionContext(addCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddCacheRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(addCacheRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new AddCacheResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds one or more tags to the specified resource. You use tags to add metadata to resources, which you can use to
* categorize these resources. For example, you can categorize resources by purpose, owner, environment, or team.
* Each tag consists of a key and a value, which you define. You can add tags to the following Storage Gateway
* resources:
*
*
* -
*
* Storage gateways of all types
*
*
* -
*
* Storage volumes
*
*
* -
*
* Virtual tapes
*
*
* -
*
* NFS and SMB file shares
*
*
* -
*
* File System associations
*
*
*
*
* You can create a maximum of 50 tags for each resource. Virtual tapes and storage volumes that are recovered to a
* new gateway maintain their tags.
*
*
* @param addTagsToResourceRequest
* AddTagsToResourceInput
* @return Result of the AddTagsToResource operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.AddTagsToResource
* @see AWS API Documentation
*/
@Override
public AddTagsToResourceResult addTagsToResource(AddTagsToResourceRequest request) {
request = beforeClientExecution(request);
return executeAddTagsToResource(request);
}
@SdkInternalApi
final AddTagsToResourceResult executeAddTagsToResource(AddTagsToResourceRequest addTagsToResourceRequest) {
ExecutionContext executionContext = createExecutionContext(addTagsToResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddTagsToResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(addTagsToResourceRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddTagsToResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AddTagsToResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Configures one or more gateway local disks as upload buffer for a specified gateway. This operation is supported
* for the stored volume, cached volume, and tape gateway types.
*
*
* In the request, you specify the gateway Amazon Resource Name (ARN) to which you want to add upload buffer, and
* one or more disk IDs that you want to configure as upload buffer.
*
*
* @param addUploadBufferRequest
* @return Result of the AddUploadBuffer operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.AddUploadBuffer
* @see AWS
* API Documentation
*/
@Override
public AddUploadBufferResult addUploadBuffer(AddUploadBufferRequest request) {
request = beforeClientExecution(request);
return executeAddUploadBuffer(request);
}
@SdkInternalApi
final AddUploadBufferResult executeAddUploadBuffer(AddUploadBufferRequest addUploadBufferRequest) {
ExecutionContext executionContext = createExecutionContext(addUploadBufferRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddUploadBufferRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(addUploadBufferRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddUploadBuffer");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AddUploadBufferResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Configures one or more gateway local disks as working storage for a gateway. This operation is only supported in
* the stored volume gateway type. This operation is deprecated in cached volume API version 20120630. Use
* AddUploadBuffer instead.
*
*
*
* Working storage is also referred to as upload buffer. You can also use the AddUploadBuffer operation to
* add upload buffer to a stored volume gateway.
*
*
*
* In the request, you specify the gateway Amazon Resource Name (ARN) to which you want to add working storage, and
* one or more disk IDs that you want to configure as working storage.
*
*
* @param addWorkingStorageRequest
* A JSON object containing one or more of the following fields:
*
* -
*
*
* @return Result of the AddWorkingStorage operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.AddWorkingStorage
* @see AWS API Documentation
*/
@Override
public AddWorkingStorageResult addWorkingStorage(AddWorkingStorageRequest request) {
request = beforeClientExecution(request);
return executeAddWorkingStorage(request);
}
@SdkInternalApi
final AddWorkingStorageResult executeAddWorkingStorage(AddWorkingStorageRequest addWorkingStorageRequest) {
ExecutionContext executionContext = createExecutionContext(addWorkingStorageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddWorkingStorageRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(addWorkingStorageRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddWorkingStorage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AddWorkingStorageResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Assigns a tape to a tape pool for archiving. The tape assigned to a pool is archived in the S3 storage class that
* is associated with the pool. When you use your backup application to eject the tape, the tape is archived
* directly into the S3 storage class (S3 Glacier or S3 Glacier Deep Archive) that corresponds to the pool.
*
*
* @param assignTapePoolRequest
* @return Result of the AssignTapePool operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.AssignTapePool
* @see AWS
* API Documentation
*/
@Override
public AssignTapePoolResult assignTapePool(AssignTapePoolRequest request) {
request = beforeClientExecution(request);
return executeAssignTapePool(request);
}
@SdkInternalApi
final AssignTapePoolResult executeAssignTapePool(AssignTapePoolRequest assignTapePoolRequest) {
ExecutionContext executionContext = createExecutionContext(assignTapePoolRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssignTapePoolRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(assignTapePoolRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssignTapePool");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AssignTapePoolResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associate an Amazon FSx file system with the FSx File Gateway. After the association process is complete, the
* file shares on the Amazon FSx file system are available for access through the gateway. This operation only
* supports the FSx File Gateway type.
*
*
* @param associateFileSystemRequest
* @return Result of the AssociateFileSystem operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.AssociateFileSystem
* @see AWS API Documentation
*/
@Override
public AssociateFileSystemResult associateFileSystem(AssociateFileSystemRequest request) {
request = beforeClientExecution(request);
return executeAssociateFileSystem(request);
}
@SdkInternalApi
final AssociateFileSystemResult executeAssociateFileSystem(AssociateFileSystemRequest associateFileSystemRequest) {
ExecutionContext executionContext = createExecutionContext(associateFileSystemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssociateFileSystemRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(associateFileSystemRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssociateFileSystem");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AssociateFileSystemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Connects a volume to an iSCSI connection and then attaches the volume to the specified gateway. Detaching and
* attaching a volume enables you to recover your data from one gateway to a different gateway without creating a
* snapshot. It also makes it easier to move your volumes from an on-premises gateway to a gateway hosted on an
* Amazon EC2 instance.
*
*
* @param attachVolumeRequest
* AttachVolumeInput
* @return Result of the AttachVolume operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.AttachVolume
* @see AWS
* API Documentation
*/
@Override
public AttachVolumeResult attachVolume(AttachVolumeRequest request) {
request = beforeClientExecution(request);
return executeAttachVolume(request);
}
@SdkInternalApi
final AttachVolumeResult executeAttachVolume(AttachVolumeRequest attachVolumeRequest) {
ExecutionContext executionContext = createExecutionContext(attachVolumeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AttachVolumeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(attachVolumeRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AttachVolume");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AttachVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Cancels archiving of a virtual tape to the virtual tape shelf (VTS) after the archiving process is initiated.
* This operation is only supported in the tape gateway type.
*
*
* @param cancelArchivalRequest
* CancelArchivalInput
* @return Result of the CancelArchival operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CancelArchival
* @see AWS
* API Documentation
*/
@Override
public CancelArchivalResult cancelArchival(CancelArchivalRequest request) {
request = beforeClientExecution(request);
return executeCancelArchival(request);
}
@SdkInternalApi
final CancelArchivalResult executeCancelArchival(CancelArchivalRequest cancelArchivalRequest) {
ExecutionContext executionContext = createExecutionContext(cancelArchivalRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelArchivalRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(cancelArchivalRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelArchival");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CancelArchivalResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Cancels retrieval of a virtual tape from the virtual tape shelf (VTS) to a gateway after the retrieval process is
* initiated. The virtual tape is returned to the VTS. This operation is only supported in the tape gateway type.
*
*
* @param cancelRetrievalRequest
* CancelRetrievalInput
* @return Result of the CancelRetrieval operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CancelRetrieval
* @see AWS
* API Documentation
*/
@Override
public CancelRetrievalResult cancelRetrieval(CancelRetrievalRequest request) {
request = beforeClientExecution(request);
return executeCancelRetrieval(request);
}
@SdkInternalApi
final CancelRetrievalResult executeCancelRetrieval(CancelRetrievalRequest cancelRetrievalRequest) {
ExecutionContext executionContext = createExecutionContext(cancelRetrievalRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelRetrievalRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(cancelRetrievalRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelRetrieval");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CancelRetrievalResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a cached volume on a specified cached volume gateway. This operation is only supported in the cached
* volume gateway type.
*
*
*
* Cache storage must be allocated to the gateway before you can create a cached volume. Use the AddCache
* operation to add cache storage to a gateway.
*
*
*
* In the request, you must specify the gateway, size of the volume in bytes, the iSCSI target name, an IP address
* on which to expose the target, and a unique client token. In response, the gateway creates the volume and returns
* information about it. This information includes the volume Amazon Resource Name (ARN), its size, and the iSCSI
* target ARN that initiators can use to connect to the volume target.
*
*
* Optionally, you can provide the ARN for an existing volume as the SourceVolumeARN for this cached
* volume, which creates an exact copy of the existing volume’s latest recovery point. The
* VolumeSizeInBytes value must be equal to or larger than the size of the copied volume, in bytes.
*
*
* @param createCachediSCSIVolumeRequest
* @return Result of the CreateCachediSCSIVolume operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CreateCachediSCSIVolume
* @see AWS API Documentation
*/
@Override
public CreateCachediSCSIVolumeResult createCachediSCSIVolume(CreateCachediSCSIVolumeRequest request) {
request = beforeClientExecution(request);
return executeCreateCachediSCSIVolume(request);
}
@SdkInternalApi
final CreateCachediSCSIVolumeResult executeCreateCachediSCSIVolume(CreateCachediSCSIVolumeRequest createCachediSCSIVolumeRequest) {
ExecutionContext executionContext = createExecutionContext(createCachediSCSIVolumeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCachediSCSIVolumeRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createCachediSCSIVolumeRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCachediSCSIVolume");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateCachediSCSIVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a Network File System (NFS) file share on an existing S3 File Gateway. In Storage Gateway, a file share
* is a file system mount point backed by Amazon S3 cloud storage. Storage Gateway exposes file shares using an NFS
* interface. This operation is only supported for S3 File Gateways.
*
*
*
* S3 File gateway requires Security Token Service (Amazon Web Services STS) to be activated to enable you to create
* a file share. Make sure Amazon Web Services STS is activated in the Amazon Web Services Region you are creating
* your S3 File Gateway in. If Amazon Web Services STS is not activated in the Amazon Web Services Region, activate
* it. For information about how to activate Amazon Web Services STS, see Activating and
* deactivating Amazon Web Services STS in an Amazon Web Services Region in the Identity and Access
* Management User Guide.
*
*
* S3 File Gateways do not support creating hard or symbolic links on a file share.
*
*
*
* @param createNFSFileShareRequest
* CreateNFSFileShareInput
* @return Result of the CreateNFSFileShare operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CreateNFSFileShare
* @see AWS API Documentation
*/
@Override
public CreateNFSFileShareResult createNFSFileShare(CreateNFSFileShareRequest request) {
request = beforeClientExecution(request);
return executeCreateNFSFileShare(request);
}
@SdkInternalApi
final CreateNFSFileShareResult executeCreateNFSFileShare(CreateNFSFileShareRequest createNFSFileShareRequest) {
ExecutionContext executionContext = createExecutionContext(createNFSFileShareRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateNFSFileShareRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createNFSFileShareRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateNFSFileShare");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateNFSFileShareResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a Server Message Block (SMB) file share on an existing S3 File Gateway. In Storage Gateway, a file share
* is a file system mount point backed by Amazon S3 cloud storage. Storage Gateway exposes file shares using an SMB
* interface. This operation is only supported for S3 File Gateways.
*
*
*
* S3 File Gateways require Security Token Service (Amazon Web Services STS) to be activated to enable you to create
* a file share. Make sure that Amazon Web Services STS is activated in the Amazon Web Services Region you are
* creating your S3 File Gateway in. If Amazon Web Services STS is not activated in this Amazon Web Services Region,
* activate it. For information about how to activate Amazon Web Services STS, see Activating and
* deactivating Amazon Web Services STS in an Amazon Web Services Region in the Identity and Access
* Management User Guide.
*
*
* File gateways don't support creating hard or symbolic links on a file share.
*
*
*
* @param createSMBFileShareRequest
* CreateSMBFileShareInput
* @return Result of the CreateSMBFileShare operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CreateSMBFileShare
* @see AWS API Documentation
*/
@Override
public CreateSMBFileShareResult createSMBFileShare(CreateSMBFileShareRequest request) {
request = beforeClientExecution(request);
return executeCreateSMBFileShare(request);
}
@SdkInternalApi
final CreateSMBFileShareResult executeCreateSMBFileShare(CreateSMBFileShareRequest createSMBFileShareRequest) {
ExecutionContext executionContext = createExecutionContext(createSMBFileShareRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateSMBFileShareRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createSMBFileShareRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateSMBFileShare");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateSMBFileShareResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Initiates a snapshot of a volume.
*
*
* Storage Gateway provides the ability to back up point-in-time snapshots of your data to Amazon Simple Storage
* (Amazon S3) for durable off-site recovery, and also import the data to an Amazon Elastic Block Store (EBS) volume
* in Amazon Elastic Compute Cloud (EC2). You can take snapshots of your gateway volume on a scheduled or ad hoc
* basis. This API enables you to take an ad hoc snapshot. For more information, see Editing a snapshot schedule.
*
*
* In the CreateSnapshot request, you identify the volume by providing its Amazon Resource Name (ARN).
* You must also provide description for the snapshot. When Storage Gateway takes the snapshot of specified volume,
* the snapshot and description appears in the Storage Gateway console. In response, Storage Gateway returns you a
* snapshot ID. You can use this snapshot ID to check the snapshot progress or later use it when you want to create
* a volume from a snapshot. This operation is only supported in stored and cached volume gateway type.
*
*
*
* To list or delete a snapshot, you must use the Amazon EC2 API. For more information, see DescribeSnapshots or
* DeleteSnapshot in
* the Amazon Elastic Compute Cloud API Reference.
*
*
*
* Volume and snapshot IDs are changing to a longer length ID format. For more information, see the important note
* on the Welcome page.
*
*
*
* @param createSnapshotRequest
* A JSON object containing one or more of the following fields:
*
* -
*
*
* -
*
*
* @return Result of the CreateSnapshot operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @throws ServiceUnavailableErrorException
* An internal server error has occurred because the service is unavailable. For more information, see the
* error and message fields.
* @sample AWSStorageGateway.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, "Storage Gateway");
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);
}
}
/**
*
* Initiates a snapshot of a gateway from a volume recovery point. This operation is only supported in the cached
* volume gateway type.
*
*
* A volume recovery point is a point in time at which all data of the volume is consistent and from which you can
* create a snapshot. To get a list of volume recovery point for cached volume gateway, use
* ListVolumeRecoveryPoints.
*
*
* In the CreateSnapshotFromVolumeRecoveryPoint request, you identify the volume by providing its
* Amazon Resource Name (ARN). You must also provide a description for the snapshot. When the gateway takes a
* snapshot of the specified volume, the snapshot and its description appear in the Storage Gateway console. In
* response, the gateway returns you a snapshot ID. You can use this snapshot ID to check the snapshot progress or
* later use it when you want to create a volume from a snapshot.
*
*
*
* To list or delete a snapshot, you must use the Amazon EC2 API. For more information, see DescribeSnapshots or
* DeleteSnapshot in
* the Amazon Elastic Compute Cloud API Reference.
*
*
*
* @param createSnapshotFromVolumeRecoveryPointRequest
* @return Result of the CreateSnapshotFromVolumeRecoveryPoint operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @throws ServiceUnavailableErrorException
* An internal server error has occurred because the service is unavailable. For more information, see the
* error and message fields.
* @sample AWSStorageGateway.CreateSnapshotFromVolumeRecoveryPoint
* @see AWS API Documentation
*/
@Override
public CreateSnapshotFromVolumeRecoveryPointResult createSnapshotFromVolumeRecoveryPoint(CreateSnapshotFromVolumeRecoveryPointRequest request) {
request = beforeClientExecution(request);
return executeCreateSnapshotFromVolumeRecoveryPoint(request);
}
@SdkInternalApi
final CreateSnapshotFromVolumeRecoveryPointResult executeCreateSnapshotFromVolumeRecoveryPoint(
CreateSnapshotFromVolumeRecoveryPointRequest createSnapshotFromVolumeRecoveryPointRequest) {
ExecutionContext executionContext = createExecutionContext(createSnapshotFromVolumeRecoveryPointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateSnapshotFromVolumeRecoveryPointRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createSnapshotFromVolumeRecoveryPointRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateSnapshotFromVolumeRecoveryPoint");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateSnapshotFromVolumeRecoveryPointResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a volume on a specified gateway. This operation is only supported in the stored volume gateway type.
*
*
* The size of the volume to create is inferred from the disk size. You can choose to preserve existing data on the
* disk, create volume from an existing snapshot, or create an empty volume. If you choose to create an empty
* gateway volume, then any existing data on the disk is erased.
*
*
* In the request, you must specify the gateway and the disk information on which you are creating the volume. In
* response, the gateway creates the volume and returns volume information such as the volume Amazon Resource Name
* (ARN), its size, and the iSCSI target ARN that initiators can use to connect to the volume target.
*
*
* @param createStorediSCSIVolumeRequest
* A JSON object containing one or more of the following fields:
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* @return Result of the CreateStorediSCSIVolume operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CreateStorediSCSIVolume
* @see AWS API Documentation
*/
@Override
public CreateStorediSCSIVolumeResult createStorediSCSIVolume(CreateStorediSCSIVolumeRequest request) {
request = beforeClientExecution(request);
return executeCreateStorediSCSIVolume(request);
}
@SdkInternalApi
final CreateStorediSCSIVolumeResult executeCreateStorediSCSIVolume(CreateStorediSCSIVolumeRequest createStorediSCSIVolumeRequest) {
ExecutionContext executionContext = createExecutionContext(createStorediSCSIVolumeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateStorediSCSIVolumeRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createStorediSCSIVolumeRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateStorediSCSIVolume");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateStorediSCSIVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new custom tape pool. You can use custom tape pool to enable tape retention lock on tapes that are
* archived in the custom pool.
*
*
* @param createTapePoolRequest
* @return Result of the CreateTapePool operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CreateTapePool
* @see AWS
* API Documentation
*/
@Override
public CreateTapePoolResult createTapePool(CreateTapePoolRequest request) {
request = beforeClientExecution(request);
return executeCreateTapePool(request);
}
@SdkInternalApi
final CreateTapePoolResult executeCreateTapePool(CreateTapePoolRequest createTapePoolRequest) {
ExecutionContext executionContext = createExecutionContext(createTapePoolRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateTapePoolRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createTapePoolRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateTapePool");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateTapePoolResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a virtual tape by using your own barcode. You write data to the virtual tape and then archive the tape. A
* barcode is unique and cannot be reused if it has already been used on a tape. This applies to barcodes used on
* deleted tapes. This operation is only supported in the tape gateway type.
*
*
*
* Cache storage must be allocated to the gateway before you can create a virtual tape. Use the AddCache
* operation to add cache storage to a gateway.
*
*
*
* @param createTapeWithBarcodeRequest
* CreateTapeWithBarcodeInput
* @return Result of the CreateTapeWithBarcode operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CreateTapeWithBarcode
* @see AWS API Documentation
*/
@Override
public CreateTapeWithBarcodeResult createTapeWithBarcode(CreateTapeWithBarcodeRequest request) {
request = beforeClientExecution(request);
return executeCreateTapeWithBarcode(request);
}
@SdkInternalApi
final CreateTapeWithBarcodeResult executeCreateTapeWithBarcode(CreateTapeWithBarcodeRequest createTapeWithBarcodeRequest) {
ExecutionContext executionContext = createExecutionContext(createTapeWithBarcodeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateTapeWithBarcodeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createTapeWithBarcodeRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateTapeWithBarcode");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateTapeWithBarcodeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates one or more virtual tapes. You write data to the virtual tapes and then archive the tapes. This operation
* is only supported in the tape gateway type.
*
*
*
* Cache storage must be allocated to the gateway before you can create virtual tapes. Use the AddCache
* operation to add cache storage to a gateway.
*
*
*
* @param createTapesRequest
* CreateTapesInput
* @return Result of the CreateTapes operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.CreateTapes
* @see AWS API
* Documentation
*/
@Override
public CreateTapesResult createTapes(CreateTapesRequest request) {
request = beforeClientExecution(request);
return executeCreateTapes(request);
}
@SdkInternalApi
final CreateTapesResult executeCreateTapes(CreateTapesRequest createTapesRequest) {
ExecutionContext executionContext = createExecutionContext(createTapesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateTapesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createTapesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateTapes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateTapesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the automatic tape creation policy of a gateway. If you delete this policy, new virtual tapes must be
* created manually. Use the Amazon Resource Name (ARN) of the gateway in your request to remove the policy.
*
*
* @param deleteAutomaticTapeCreationPolicyRequest
* @return Result of the DeleteAutomaticTapeCreationPolicy operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteAutomaticTapeCreationPolicy
* @see AWS API Documentation
*/
@Override
public DeleteAutomaticTapeCreationPolicyResult deleteAutomaticTapeCreationPolicy(DeleteAutomaticTapeCreationPolicyRequest request) {
request = beforeClientExecution(request);
return executeDeleteAutomaticTapeCreationPolicy(request);
}
@SdkInternalApi
final DeleteAutomaticTapeCreationPolicyResult executeDeleteAutomaticTapeCreationPolicy(
DeleteAutomaticTapeCreationPolicyRequest deleteAutomaticTapeCreationPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(deleteAutomaticTapeCreationPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteAutomaticTapeCreationPolicyRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteAutomaticTapeCreationPolicyRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteAutomaticTapeCreationPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteAutomaticTapeCreationPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the bandwidth rate limits of a gateway. You can delete either the upload and download bandwidth rate
* limit, or you can delete both. If you delete only one of the limits, the other limit remains unchanged. To
* specify which gateway to work with, use the Amazon Resource Name (ARN) of the gateway in your request. This
* operation is supported only for the stored volume, cached volume, and tape gateway types.
*
*
* @param deleteBandwidthRateLimitRequest
* A JSON object containing the following fields:
*
* -
*
*
* @return Result of the DeleteBandwidthRateLimit operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteBandwidthRateLimit
* @see AWS API Documentation
*/
@Override
public DeleteBandwidthRateLimitResult deleteBandwidthRateLimit(DeleteBandwidthRateLimitRequest request) {
request = beforeClientExecution(request);
return executeDeleteBandwidthRateLimit(request);
}
@SdkInternalApi
final DeleteBandwidthRateLimitResult executeDeleteBandwidthRateLimit(DeleteBandwidthRateLimitRequest deleteBandwidthRateLimitRequest) {
ExecutionContext executionContext = createExecutionContext(deleteBandwidthRateLimitRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteBandwidthRateLimitRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteBandwidthRateLimitRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteBandwidthRateLimit");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteBandwidthRateLimitResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes Challenge-Handshake Authentication Protocol (CHAP) credentials for a specified iSCSI target and initiator
* pair. This operation is supported in volume and tape gateway types.
*
*
* @param deleteChapCredentialsRequest
* A JSON object containing one or more of the following fields:
*
* -
*
*
* -
*
*
* @return Result of the DeleteChapCredentials operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteChapCredentials
* @see AWS API Documentation
*/
@Override
public DeleteChapCredentialsResult deleteChapCredentials(DeleteChapCredentialsRequest request) {
request = beforeClientExecution(request);
return executeDeleteChapCredentials(request);
}
@SdkInternalApi
final DeleteChapCredentialsResult executeDeleteChapCredentials(DeleteChapCredentialsRequest deleteChapCredentialsRequest) {
ExecutionContext executionContext = createExecutionContext(deleteChapCredentialsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteChapCredentialsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteChapCredentialsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteChapCredentials");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteChapCredentialsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a file share from an S3 File Gateway. This operation is only supported for S3 File Gateways.
*
*
* @param deleteFileShareRequest
* DeleteFileShareInput
* @return Result of the DeleteFileShare operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteFileShare
* @see AWS
* API Documentation
*/
@Override
public DeleteFileShareResult deleteFileShare(DeleteFileShareRequest request) {
request = beforeClientExecution(request);
return executeDeleteFileShare(request);
}
@SdkInternalApi
final DeleteFileShareResult executeDeleteFileShare(DeleteFileShareRequest deleteFileShareRequest) {
ExecutionContext executionContext = createExecutionContext(deleteFileShareRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteFileShareRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteFileShareRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteFileShare");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteFileShareResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a gateway. To specify which gateway to delete, use the Amazon Resource Name (ARN) of the gateway in your
* request. The operation deletes the gateway; however, it does not delete the gateway virtual machine (VM) from
* your host computer.
*
*
* After you delete a gateway, you cannot reactivate it. Completed snapshots of the gateway volumes are not deleted
* upon deleting the gateway, however, pending snapshots will not complete. After you delete a gateway, your next
* step is to remove it from your environment.
*
*
*
* You no longer pay software charges after the gateway is deleted; however, your existing Amazon EBS snapshots
* persist and you will continue to be billed for these snapshots. You can choose to remove all remaining Amazon EBS
* snapshots by canceling your Amazon EC2 subscription. If you prefer not to cancel your Amazon EC2 subscription,
* you can delete your snapshots using the Amazon EC2 console. For more information, see the Storage Gateway detail page.
*
*
*
* @param deleteGatewayRequest
* A JSON object containing the ID of the gateway to delete.
* @return Result of the DeleteGateway operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteGateway
* @see AWS
* API Documentation
*/
@Override
public DeleteGatewayResult deleteGateway(DeleteGatewayRequest request) {
request = beforeClientExecution(request);
return executeDeleteGateway(request);
}
@SdkInternalApi
final DeleteGatewayResult executeDeleteGateway(DeleteGatewayRequest deleteGatewayRequest) {
ExecutionContext executionContext = createExecutionContext(deleteGatewayRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteGatewayRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteGatewayRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteGateway");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteGatewayResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a snapshot of a volume.
*
*
* You can take snapshots of your gateway volumes on a scheduled or ad hoc basis. This API action enables you to
* delete a snapshot schedule for a volume. For more information, see Backing up your
* volumes. In the DeleteSnapshotSchedule request, you identify the volume by providing its Amazon
* Resource Name (ARN). This operation is only supported for cached volume gateway types.
*
*
*
* To list or delete a snapshot, you must use the Amazon EC2 API. For more information, go to DescribeSnapshots in
* the Amazon Elastic Compute Cloud API Reference.
*
*
*
* @param deleteSnapshotScheduleRequest
* @return Result of the DeleteSnapshotSchedule operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteSnapshotSchedule
* @see AWS API Documentation
*/
@Override
public DeleteSnapshotScheduleResult deleteSnapshotSchedule(DeleteSnapshotScheduleRequest request) {
request = beforeClientExecution(request);
return executeDeleteSnapshotSchedule(request);
}
@SdkInternalApi
final DeleteSnapshotScheduleResult executeDeleteSnapshotSchedule(DeleteSnapshotScheduleRequest deleteSnapshotScheduleRequest) {
ExecutionContext executionContext = createExecutionContext(deleteSnapshotScheduleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteSnapshotScheduleRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteSnapshotScheduleRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteSnapshotSchedule");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteSnapshotScheduleResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified virtual tape. This operation is only supported in the tape gateway type.
*
*
* @param deleteTapeRequest
* DeleteTapeInput
* @return Result of the DeleteTape operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteTape
* @see AWS API
* Documentation
*/
@Override
public DeleteTapeResult deleteTape(DeleteTapeRequest request) {
request = beforeClientExecution(request);
return executeDeleteTape(request);
}
@SdkInternalApi
final DeleteTapeResult executeDeleteTape(DeleteTapeRequest deleteTapeRequest) {
ExecutionContext executionContext = createExecutionContext(deleteTapeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteTapeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteTapeRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteTape");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteTapeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified virtual tape from the virtual tape shelf (VTS). This operation is only supported in the
* tape gateway type.
*
*
* @param deleteTapeArchiveRequest
* DeleteTapeArchiveInput
* @return Result of the DeleteTapeArchive operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteTapeArchive
* @see AWS API Documentation
*/
@Override
public DeleteTapeArchiveResult deleteTapeArchive(DeleteTapeArchiveRequest request) {
request = beforeClientExecution(request);
return executeDeleteTapeArchive(request);
}
@SdkInternalApi
final DeleteTapeArchiveResult executeDeleteTapeArchive(DeleteTapeArchiveRequest deleteTapeArchiveRequest) {
ExecutionContext executionContext = createExecutionContext(deleteTapeArchiveRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteTapeArchiveRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteTapeArchiveRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteTapeArchive");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteTapeArchiveResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Delete a custom tape pool. A custom tape pool can only be deleted if there are no tapes in the pool and if there
* are no automatic tape creation policies that reference the custom tape pool.
*
*
* @param deleteTapePoolRequest
* @return Result of the DeleteTapePool operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DeleteTapePool
* @see AWS
* API Documentation
*/
@Override
public DeleteTapePoolResult deleteTapePool(DeleteTapePoolRequest request) {
request = beforeClientExecution(request);
return executeDeleteTapePool(request);
}
@SdkInternalApi
final DeleteTapePoolResult executeDeleteTapePool(DeleteTapePoolRequest deleteTapePoolRequest) {
ExecutionContext executionContext = createExecutionContext(deleteTapePoolRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteTapePoolRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteTapePoolRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteTapePool");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteTapePoolResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified storage volume that you previously created using the CreateCachediSCSIVolume or
* CreateStorediSCSIVolume API. This operation is only supported in the cached volume and stored volume
* types. For stored volume gateways, the local disk that was configured as the storage volume is not deleted. You
* can reuse the local disk to create another storage volume.
*
*
* Before you delete a volume, make sure there are no iSCSI connections to the volume you are deleting. You should
* also make sure there is no snapshot in progress. You can use the Amazon Elastic Compute Cloud (Amazon EC2) API to
* query snapshots on the volume you are deleting and check the snapshot status. For more information, go to
* DescribeSnapshots in the Amazon Elastic Compute Cloud API Reference.
*
*
* In the request, you must provide the Amazon Resource Name (ARN) of the storage volume you want to delete.
*
*
* @param deleteVolumeRequest
* A JSON object containing the DeleteVolumeInput$VolumeARN to delete.
* @return Result of the DeleteVolume operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.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, "Storage Gateway");
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 information about the most recent high availability monitoring test that was performed on the host in a
* cluster. If a test isn't performed, the status and start time in the response would be null.
*
*
* @param describeAvailabilityMonitorTestRequest
* @return Result of the DescribeAvailabilityMonitorTest operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeAvailabilityMonitorTest
* @see AWS API Documentation
*/
@Override
public DescribeAvailabilityMonitorTestResult describeAvailabilityMonitorTest(DescribeAvailabilityMonitorTestRequest request) {
request = beforeClientExecution(request);
return executeDescribeAvailabilityMonitorTest(request);
}
@SdkInternalApi
final DescribeAvailabilityMonitorTestResult executeDescribeAvailabilityMonitorTest(
DescribeAvailabilityMonitorTestRequest describeAvailabilityMonitorTestRequest) {
ExecutionContext executionContext = createExecutionContext(describeAvailabilityMonitorTestRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAvailabilityMonitorTestRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeAvailabilityMonitorTestRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAvailabilityMonitorTest");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeAvailabilityMonitorTestResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the bandwidth rate limits of a gateway. By default, these limits are not set, which means no bandwidth
* rate limiting is in effect. This operation is supported only for the stored volume, cached volume, and tape
* gateway types. To describe bandwidth rate limits for S3 file gateways, use
* DescribeBandwidthRateLimitSchedule.
*
*
* This operation returns a value for a bandwidth rate limit only if the limit is set. If no limits are set for the
* gateway, then this operation returns only the gateway ARN in the response body. To specify which gateway to
* describe, use the Amazon Resource Name (ARN) of the gateway in your request.
*
*
* @param describeBandwidthRateLimitRequest
* A JSON object containing the Amazon Resource Name (ARN) of the gateway.
* @return Result of the DescribeBandwidthRateLimit operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeBandwidthRateLimit
* @see AWS API Documentation
*/
@Override
public DescribeBandwidthRateLimitResult describeBandwidthRateLimit(DescribeBandwidthRateLimitRequest request) {
request = beforeClientExecution(request);
return executeDescribeBandwidthRateLimit(request);
}
@SdkInternalApi
final DescribeBandwidthRateLimitResult executeDescribeBandwidthRateLimit(DescribeBandwidthRateLimitRequest describeBandwidthRateLimitRequest) {
ExecutionContext executionContext = createExecutionContext(describeBandwidthRateLimitRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeBandwidthRateLimitRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeBandwidthRateLimitRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeBandwidthRateLimit");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeBandwidthRateLimitResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about the bandwidth rate limit schedule of a gateway. By default, gateways do not have
* bandwidth rate limit schedules, which means no bandwidth rate limiting is in effect. This operation is supported
* only for volume, tape and S3 file gateways. FSx file gateways do not support bandwidth rate limits.
*
*
* This operation returns information about a gateway's bandwidth rate limit schedule. A bandwidth rate limit
* schedule consists of one or more bandwidth rate limit intervals. A bandwidth rate limit interval defines a period
* of time on one or more days of the week, during which bandwidth rate limits are specified for uploading,
* downloading, or both.
*
*
* A bandwidth rate limit interval consists of one or more days of the week, a start hour and minute, an ending hour
* and minute, and bandwidth rate limits for uploading and downloading
*
*
* If no bandwidth rate limit schedule intervals are set for the gateway, this operation returns an empty response.
* To specify which gateway to describe, use the Amazon Resource Name (ARN) of the gateway in your request.
*
*
* @param describeBandwidthRateLimitScheduleRequest
* @return Result of the DescribeBandwidthRateLimitSchedule operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeBandwidthRateLimitSchedule
* @see AWS API Documentation
*/
@Override
public DescribeBandwidthRateLimitScheduleResult describeBandwidthRateLimitSchedule(DescribeBandwidthRateLimitScheduleRequest request) {
request = beforeClientExecution(request);
return executeDescribeBandwidthRateLimitSchedule(request);
}
@SdkInternalApi
final DescribeBandwidthRateLimitScheduleResult executeDescribeBandwidthRateLimitSchedule(
DescribeBandwidthRateLimitScheduleRequest describeBandwidthRateLimitScheduleRequest) {
ExecutionContext executionContext = createExecutionContext(describeBandwidthRateLimitScheduleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeBandwidthRateLimitScheduleRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeBandwidthRateLimitScheduleRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeBandwidthRateLimitSchedule");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeBandwidthRateLimitScheduleResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about the cache of a gateway. This operation is only supported in the cached volume, tape,
* and file gateway types.
*
*
* The response includes disk IDs that are configured as cache, and it includes the amount of cache allocated and
* used.
*
*
* @param describeCacheRequest
* @return Result of the DescribeCache operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeCache
* @see AWS
* API Documentation
*/
@Override
public DescribeCacheResult describeCache(DescribeCacheRequest request) {
request = beforeClientExecution(request);
return executeDescribeCache(request);
}
@SdkInternalApi
final DescribeCacheResult executeDescribeCache(DescribeCacheRequest describeCacheRequest) {
ExecutionContext executionContext = createExecutionContext(describeCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCacheRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeCacheRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeCacheResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a description of the gateway volumes specified in the request. This operation is only supported in the
* cached volume gateway types.
*
*
* The list of gateway volumes in the request must be from one gateway. In the response, Storage Gateway returns
* volume information sorted by volume Amazon Resource Name (ARN).
*
*
* @param describeCachediSCSIVolumesRequest
* @return Result of the DescribeCachediSCSIVolumes operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeCachediSCSIVolumes
* @see AWS API Documentation
*/
@Override
public DescribeCachediSCSIVolumesResult describeCachediSCSIVolumes(DescribeCachediSCSIVolumesRequest request) {
request = beforeClientExecution(request);
return executeDescribeCachediSCSIVolumes(request);
}
@SdkInternalApi
final DescribeCachediSCSIVolumesResult executeDescribeCachediSCSIVolumes(DescribeCachediSCSIVolumesRequest describeCachediSCSIVolumesRequest) {
ExecutionContext executionContext = createExecutionContext(describeCachediSCSIVolumesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCachediSCSIVolumesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeCachediSCSIVolumesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCachediSCSIVolumes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeCachediSCSIVolumesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns an array of Challenge-Handshake Authentication Protocol (CHAP) credentials information for a specified
* iSCSI target, one for each target-initiator pair. This operation is supported in the volume and tape gateway
* types.
*
*
* @param describeChapCredentialsRequest
* A JSON object containing the Amazon Resource Name (ARN) of the iSCSI volume target.
* @return Result of the DescribeChapCredentials operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeChapCredentials
* @see AWS API Documentation
*/
@Override
public DescribeChapCredentialsResult describeChapCredentials(DescribeChapCredentialsRequest request) {
request = beforeClientExecution(request);
return executeDescribeChapCredentials(request);
}
@SdkInternalApi
final DescribeChapCredentialsResult executeDescribeChapCredentials(DescribeChapCredentialsRequest describeChapCredentialsRequest) {
ExecutionContext executionContext = createExecutionContext(describeChapCredentialsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeChapCredentialsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeChapCredentialsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeChapCredentials");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeChapCredentialsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets the file system association information. This operation is only supported for FSx File Gateways.
*
*
* @param describeFileSystemAssociationsRequest
* @return Result of the DescribeFileSystemAssociations operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeFileSystemAssociations
* @see AWS API Documentation
*/
@Override
public DescribeFileSystemAssociationsResult describeFileSystemAssociations(DescribeFileSystemAssociationsRequest request) {
request = beforeClientExecution(request);
return executeDescribeFileSystemAssociations(request);
}
@SdkInternalApi
final DescribeFileSystemAssociationsResult executeDescribeFileSystemAssociations(DescribeFileSystemAssociationsRequest describeFileSystemAssociationsRequest) {
ExecutionContext executionContext = createExecutionContext(describeFileSystemAssociationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeFileSystemAssociationsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeFileSystemAssociationsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeFileSystemAssociations");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeFileSystemAssociationsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns metadata about a gateway such as its name, network interfaces, configured time zone, and the state
* (whether the gateway is running or not). To specify which gateway to describe, use the Amazon Resource Name (ARN)
* of the gateway in your request.
*
*
* @param describeGatewayInformationRequest
* A JSON object containing the ID of the gateway.
* @return Result of the DescribeGatewayInformation operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeGatewayInformation
* @see AWS API Documentation
*/
@Override
public DescribeGatewayInformationResult describeGatewayInformation(DescribeGatewayInformationRequest request) {
request = beforeClientExecution(request);
return executeDescribeGatewayInformation(request);
}
@SdkInternalApi
final DescribeGatewayInformationResult executeDescribeGatewayInformation(DescribeGatewayInformationRequest describeGatewayInformationRequest) {
ExecutionContext executionContext = createExecutionContext(describeGatewayInformationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeGatewayInformationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeGatewayInformationRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeGatewayInformation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeGatewayInformationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns your gateway's weekly maintenance start time including the day and time of the week. Note that values are
* in terms of the gateway's time zone.
*
*
* @param describeMaintenanceStartTimeRequest
* A JSON object containing the Amazon Resource Name (ARN) of the gateway.
* @return Result of the DescribeMaintenanceStartTime operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeMaintenanceStartTime
* @see AWS API Documentation
*/
@Override
public DescribeMaintenanceStartTimeResult describeMaintenanceStartTime(DescribeMaintenanceStartTimeRequest request) {
request = beforeClientExecution(request);
return executeDescribeMaintenanceStartTime(request);
}
@SdkInternalApi
final DescribeMaintenanceStartTimeResult executeDescribeMaintenanceStartTime(DescribeMaintenanceStartTimeRequest describeMaintenanceStartTimeRequest) {
ExecutionContext executionContext = createExecutionContext(describeMaintenanceStartTimeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeMaintenanceStartTimeRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeMaintenanceStartTimeRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeMaintenanceStartTime");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeMaintenanceStartTimeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets a description for one or more Network File System (NFS) file shares from an S3 File Gateway. This operation
* is only supported for S3 File Gateways.
*
*
* @param describeNFSFileSharesRequest
* DescribeNFSFileSharesInput
* @return Result of the DescribeNFSFileShares operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeNFSFileShares
* @see AWS API Documentation
*/
@Override
public DescribeNFSFileSharesResult describeNFSFileShares(DescribeNFSFileSharesRequest request) {
request = beforeClientExecution(request);
return executeDescribeNFSFileShares(request);
}
@SdkInternalApi
final DescribeNFSFileSharesResult executeDescribeNFSFileShares(DescribeNFSFileSharesRequest describeNFSFileSharesRequest) {
ExecutionContext executionContext = createExecutionContext(describeNFSFileSharesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeNFSFileSharesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeNFSFileSharesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeNFSFileShares");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeNFSFileSharesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets a description for one or more Server Message Block (SMB) file shares from a S3 File Gateway. This operation
* is only supported for S3 File Gateways.
*
*
* @param describeSMBFileSharesRequest
* DescribeSMBFileSharesInput
* @return Result of the DescribeSMBFileShares operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeSMBFileShares
* @see AWS API Documentation
*/
@Override
public DescribeSMBFileSharesResult describeSMBFileShares(DescribeSMBFileSharesRequest request) {
request = beforeClientExecution(request);
return executeDescribeSMBFileShares(request);
}
@SdkInternalApi
final DescribeSMBFileSharesResult executeDescribeSMBFileShares(DescribeSMBFileSharesRequest describeSMBFileSharesRequest) {
ExecutionContext executionContext = createExecutionContext(describeSMBFileSharesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeSMBFileSharesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeSMBFileSharesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeSMBFileShares");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeSMBFileSharesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets a description of a Server Message Block (SMB) file share settings from a file gateway. This operation is
* only supported for file gateways.
*
*
* @param describeSMBSettingsRequest
* @return Result of the DescribeSMBSettings operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeSMBSettings
* @see AWS API Documentation
*/
@Override
public DescribeSMBSettingsResult describeSMBSettings(DescribeSMBSettingsRequest request) {
request = beforeClientExecution(request);
return executeDescribeSMBSettings(request);
}
@SdkInternalApi
final DescribeSMBSettingsResult executeDescribeSMBSettings(DescribeSMBSettingsRequest describeSMBSettingsRequest) {
ExecutionContext executionContext = createExecutionContext(describeSMBSettingsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeSMBSettingsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeSMBSettingsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeSMBSettings");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeSMBSettingsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the snapshot schedule for the specified gateway volume. The snapshot schedule information includes
* intervals at which snapshots are automatically initiated on the volume. This operation is only supported in the
* cached volume and stored volume types.
*
*
* @param describeSnapshotScheduleRequest
* A JSON object containing the DescribeSnapshotScheduleInput$VolumeARN of the volume.
* @return Result of the DescribeSnapshotSchedule operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeSnapshotSchedule
* @see AWS API Documentation
*/
@Override
public DescribeSnapshotScheduleResult describeSnapshotSchedule(DescribeSnapshotScheduleRequest request) {
request = beforeClientExecution(request);
return executeDescribeSnapshotSchedule(request);
}
@SdkInternalApi
final DescribeSnapshotScheduleResult executeDescribeSnapshotSchedule(DescribeSnapshotScheduleRequest describeSnapshotScheduleRequest) {
ExecutionContext executionContext = createExecutionContext(describeSnapshotScheduleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeSnapshotScheduleRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeSnapshotScheduleRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeSnapshotSchedule");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeSnapshotScheduleResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the description of the gateway volumes specified in the request. The list of gateway volumes in the
* request must be from one gateway. In the response, Storage Gateway returns volume information sorted by volume
* ARNs. This operation is only supported in stored volume gateway type.
*
*
* @param describeStorediSCSIVolumesRequest
* A JSON object containing a list of DescribeStorediSCSIVolumesInput$VolumeARNs.
* @return Result of the DescribeStorediSCSIVolumes operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeStorediSCSIVolumes
* @see AWS API Documentation
*/
@Override
public DescribeStorediSCSIVolumesResult describeStorediSCSIVolumes(DescribeStorediSCSIVolumesRequest request) {
request = beforeClientExecution(request);
return executeDescribeStorediSCSIVolumes(request);
}
@SdkInternalApi
final DescribeStorediSCSIVolumesResult executeDescribeStorediSCSIVolumes(DescribeStorediSCSIVolumesRequest describeStorediSCSIVolumesRequest) {
ExecutionContext executionContext = createExecutionContext(describeStorediSCSIVolumesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeStorediSCSIVolumesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeStorediSCSIVolumesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeStorediSCSIVolumes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeStorediSCSIVolumesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a description of specified virtual tapes in the virtual tape shelf (VTS). This operation is only
* supported in the tape gateway type.
*
*
* If a specific TapeARN is not specified, Storage Gateway returns a description of all virtual tapes
* found in the VTS associated with your account.
*
*
* @param describeTapeArchivesRequest
* DescribeTapeArchivesInput
* @return Result of the DescribeTapeArchives operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeTapeArchives
* @see AWS API Documentation
*/
@Override
public DescribeTapeArchivesResult describeTapeArchives(DescribeTapeArchivesRequest request) {
request = beforeClientExecution(request);
return executeDescribeTapeArchives(request);
}
@SdkInternalApi
final DescribeTapeArchivesResult executeDescribeTapeArchives(DescribeTapeArchivesRequest describeTapeArchivesRequest) {
ExecutionContext executionContext = createExecutionContext(describeTapeArchivesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeTapeArchivesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeTapeArchivesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeTapeArchives");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeTapeArchivesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeTapeArchivesResult describeTapeArchives() {
return describeTapeArchives(new DescribeTapeArchivesRequest());
}
/**
*
* Returns a list of virtual tape recovery points that are available for the specified tape gateway.
*
*
* A recovery point is a point-in-time view of a virtual tape at which all the data on the virtual tape is
* consistent. If your gateway crashes, virtual tapes that have recovery points can be recovered to a new gateway.
* This operation is only supported in the tape gateway type.
*
*
* @param describeTapeRecoveryPointsRequest
* DescribeTapeRecoveryPointsInput
* @return Result of the DescribeTapeRecoveryPoints operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeTapeRecoveryPoints
* @see AWS API Documentation
*/
@Override
public DescribeTapeRecoveryPointsResult describeTapeRecoveryPoints(DescribeTapeRecoveryPointsRequest request) {
request = beforeClientExecution(request);
return executeDescribeTapeRecoveryPoints(request);
}
@SdkInternalApi
final DescribeTapeRecoveryPointsResult executeDescribeTapeRecoveryPoints(DescribeTapeRecoveryPointsRequest describeTapeRecoveryPointsRequest) {
ExecutionContext executionContext = createExecutionContext(describeTapeRecoveryPointsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeTapeRecoveryPointsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeTapeRecoveryPointsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeTapeRecoveryPoints");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeTapeRecoveryPointsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a description of the specified Amazon Resource Name (ARN) of virtual tapes. If a TapeARN is
* not specified, returns a description of all virtual tapes associated with the specified gateway. This operation
* is only supported in the tape gateway type.
*
*
* @param describeTapesRequest
* DescribeTapesInput
* @return Result of the DescribeTapes operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeTapes
* @see AWS
* API Documentation
*/
@Override
public DescribeTapesResult describeTapes(DescribeTapesRequest request) {
request = beforeClientExecution(request);
return executeDescribeTapes(request);
}
@SdkInternalApi
final DescribeTapesResult executeDescribeTapes(DescribeTapesRequest describeTapesRequest) {
ExecutionContext executionContext = createExecutionContext(describeTapesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeTapesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeTapesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeTapes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeTapesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about the upload buffer of a gateway. This operation is supported for the stored volume,
* cached volume, and tape gateway types.
*
*
* The response includes disk IDs that are configured as upload buffer space, and it includes the amount of upload
* buffer space allocated and used.
*
*
* @param describeUploadBufferRequest
* @return Result of the DescribeUploadBuffer operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeUploadBuffer
* @see AWS API Documentation
*/
@Override
public DescribeUploadBufferResult describeUploadBuffer(DescribeUploadBufferRequest request) {
request = beforeClientExecution(request);
return executeDescribeUploadBuffer(request);
}
@SdkInternalApi
final DescribeUploadBufferResult executeDescribeUploadBuffer(DescribeUploadBufferRequest describeUploadBufferRequest) {
ExecutionContext executionContext = createExecutionContext(describeUploadBufferRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeUploadBufferRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeUploadBufferRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeUploadBuffer");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeUploadBufferResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a description of virtual tape library (VTL) devices for the specified tape gateway. In the response,
* Storage Gateway returns VTL device information.
*
*
* This operation is only supported in the tape gateway type.
*
*
* @param describeVTLDevicesRequest
* DescribeVTLDevicesInput
* @return Result of the DescribeVTLDevices operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeVTLDevices
* @see AWS API Documentation
*/
@Override
public DescribeVTLDevicesResult describeVTLDevices(DescribeVTLDevicesRequest request) {
request = beforeClientExecution(request);
return executeDescribeVTLDevices(request);
}
@SdkInternalApi
final DescribeVTLDevicesResult executeDescribeVTLDevices(DescribeVTLDevicesRequest describeVTLDevicesRequest) {
ExecutionContext executionContext = createExecutionContext(describeVTLDevicesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeVTLDevicesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeVTLDevicesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeVTLDevices");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeVTLDevicesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about the working storage of a gateway. This operation is only supported in the stored
* volumes gateway type. This operation is deprecated in cached volumes API version (20120630). Use
* DescribeUploadBuffer instead.
*
*
*
* Working storage is also referred to as upload buffer. You can also use the DescribeUploadBuffer operation to add
* upload buffer to a stored volume gateway.
*
*
*
* The response includes disk IDs that are configured as working storage, and it includes the amount of working
* storage allocated and used.
*
*
* @param describeWorkingStorageRequest
* A JSON object containing the Amazon Resource Name (ARN) of the gateway.
* @return Result of the DescribeWorkingStorage operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DescribeWorkingStorage
* @see AWS API Documentation
*/
@Override
public DescribeWorkingStorageResult describeWorkingStorage(DescribeWorkingStorageRequest request) {
request = beforeClientExecution(request);
return executeDescribeWorkingStorage(request);
}
@SdkInternalApi
final DescribeWorkingStorageResult executeDescribeWorkingStorage(DescribeWorkingStorageRequest describeWorkingStorageRequest) {
ExecutionContext executionContext = createExecutionContext(describeWorkingStorageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWorkingStorageRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeWorkingStorageRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWorkingStorage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWorkingStorageResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disconnects a volume from an iSCSI connection and then detaches the volume from the specified gateway. Detaching
* and attaching a volume enables you to recover your data from one gateway to a different gateway without creating
* a snapshot. It also makes it easier to move your volumes from an on-premises gateway to a gateway hosted on an
* Amazon EC2 instance. This operation is only supported in the volume gateway type.
*
*
* @param detachVolumeRequest
* AttachVolumeInput
* @return Result of the DetachVolume operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DetachVolume
* @see AWS
* API Documentation
*/
@Override
public DetachVolumeResult detachVolume(DetachVolumeRequest request) {
request = beforeClientExecution(request);
return executeDetachVolume(request);
}
@SdkInternalApi
final DetachVolumeResult executeDetachVolume(DetachVolumeRequest detachVolumeRequest) {
ExecutionContext executionContext = createExecutionContext(detachVolumeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetachVolumeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(detachVolumeRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DetachVolume");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DetachVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disables a tape gateway when the gateway is no longer functioning. For example, if your gateway VM is damaged,
* you can disable the gateway so you can recover virtual tapes.
*
*
* Use this operation for a tape gateway that is not reachable or not functioning. This operation is only supported
* in the tape gateway type.
*
*
*
* After a gateway is disabled, it cannot be enabled.
*
*
*
* @param disableGatewayRequest
* DisableGatewayInput
* @return Result of the DisableGateway operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DisableGateway
* @see AWS
* API Documentation
*/
@Override
public DisableGatewayResult disableGateway(DisableGatewayRequest request) {
request = beforeClientExecution(request);
return executeDisableGateway(request);
}
@SdkInternalApi
final DisableGatewayResult executeDisableGateway(DisableGatewayRequest disableGatewayRequest) {
ExecutionContext executionContext = createExecutionContext(disableGatewayRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisableGatewayRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(disableGatewayRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisableGateway");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DisableGatewayResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disassociates an Amazon FSx file system from the specified gateway. After the disassociation process finishes,
* the gateway can no longer access the Amazon FSx file system. This operation is only supported in the FSx File
* Gateway type.
*
*
* @param disassociateFileSystemRequest
* @return Result of the DisassociateFileSystem operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.DisassociateFileSystem
* @see AWS API Documentation
*/
@Override
public DisassociateFileSystemResult disassociateFileSystem(DisassociateFileSystemRequest request) {
request = beforeClientExecution(request);
return executeDisassociateFileSystem(request);
}
@SdkInternalApi
final DisassociateFileSystemResult executeDisassociateFileSystem(DisassociateFileSystemRequest disassociateFileSystemRequest) {
ExecutionContext executionContext = createExecutionContext(disassociateFileSystemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisassociateFileSystemRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(disassociateFileSystemRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisassociateFileSystem");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DisassociateFileSystemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds a file gateway to an Active Directory domain. This operation is only supported for file gateways that
* support the SMB file protocol.
*
*
* @param joinDomainRequest
* JoinDomainInput
* @return Result of the JoinDomain operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.JoinDomain
* @see AWS API
* Documentation
*/
@Override
public JoinDomainResult joinDomain(JoinDomainRequest request) {
request = beforeClientExecution(request);
return executeJoinDomain(request);
}
@SdkInternalApi
final JoinDomainResult executeJoinDomain(JoinDomainRequest joinDomainRequest) {
ExecutionContext executionContext = createExecutionContext(joinDomainRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new JoinDomainRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(joinDomainRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "JoinDomain");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new JoinDomainResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the automatic tape creation policies for a gateway. If there are no automatic tape creation policies for
* the gateway, it returns an empty list.
*
*
* This operation is only supported for tape gateways.
*
*
* @param listAutomaticTapeCreationPoliciesRequest
* @return Result of the ListAutomaticTapeCreationPolicies operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListAutomaticTapeCreationPolicies
* @see AWS API Documentation
*/
@Override
public ListAutomaticTapeCreationPoliciesResult listAutomaticTapeCreationPolicies(ListAutomaticTapeCreationPoliciesRequest request) {
request = beforeClientExecution(request);
return executeListAutomaticTapeCreationPolicies(request);
}
@SdkInternalApi
final ListAutomaticTapeCreationPoliciesResult executeListAutomaticTapeCreationPolicies(
ListAutomaticTapeCreationPoliciesRequest listAutomaticTapeCreationPoliciesRequest) {
ExecutionContext executionContext = createExecutionContext(listAutomaticTapeCreationPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAutomaticTapeCreationPoliciesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listAutomaticTapeCreationPoliciesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListAutomaticTapeCreationPolicies");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListAutomaticTapeCreationPoliciesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets a list of the file shares for a specific S3 File Gateway, or the list of file shares that belong to the
* calling user account. This operation is only supported for S3 File Gateways.
*
*
* @param listFileSharesRequest
* ListFileShareInput
* @return Result of the ListFileShares operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListFileShares
* @see AWS
* API Documentation
*/
@Override
public ListFileSharesResult listFileShares(ListFileSharesRequest request) {
request = beforeClientExecution(request);
return executeListFileShares(request);
}
@SdkInternalApi
final ListFileSharesResult executeListFileShares(ListFileSharesRequest listFileSharesRequest) {
ExecutionContext executionContext = createExecutionContext(listFileSharesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListFileSharesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listFileSharesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListFileShares");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListFileSharesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets a list of FileSystemAssociationSummary objects. Each object contains a summary of a file system
* association. This operation is only supported for FSx File Gateways.
*
*
* @param listFileSystemAssociationsRequest
* @return Result of the ListFileSystemAssociations operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListFileSystemAssociations
* @see AWS API Documentation
*/
@Override
public ListFileSystemAssociationsResult listFileSystemAssociations(ListFileSystemAssociationsRequest request) {
request = beforeClientExecution(request);
return executeListFileSystemAssociations(request);
}
@SdkInternalApi
final ListFileSystemAssociationsResult executeListFileSystemAssociations(ListFileSystemAssociationsRequest listFileSystemAssociationsRequest) {
ExecutionContext executionContext = createExecutionContext(listFileSystemAssociationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListFileSystemAssociationsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listFileSystemAssociationsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListFileSystemAssociations");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListFileSystemAssociationsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists gateways owned by an Amazon Web Services account in an Amazon Web Services Region specified in the request.
* The returned list is ordered by gateway Amazon Resource Name (ARN).
*
*
* By default, the operation returns a maximum of 100 gateways. This operation supports pagination that allows you
* to optionally reduce the number of gateways returned in a response.
*
*
* If you have more gateways than are returned in a response (that is, the response returns only a truncated list of
* your gateways), the response contains a marker that you can specify in your next request to fetch the next page
* of gateways.
*
*
* @param listGatewaysRequest
* A JSON object containing zero or more of the following fields:
*
* -
*
*
* -
*
*
* @return Result of the ListGateways operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListGateways
* @see AWS
* API Documentation
*/
@Override
public ListGatewaysResult listGateways(ListGatewaysRequest request) {
request = beforeClientExecution(request);
return executeListGateways(request);
}
@SdkInternalApi
final ListGatewaysResult executeListGateways(ListGatewaysRequest listGatewaysRequest) {
ExecutionContext executionContext = createExecutionContext(listGatewaysRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListGatewaysRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listGatewaysRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListGateways");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListGatewaysResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListGatewaysResult listGateways() {
return listGateways(new ListGatewaysRequest());
}
/**
*
* Returns a list of the gateway's local disks. To specify which gateway to describe, you use the Amazon Resource
* Name (ARN) of the gateway in the body of the request.
*
*
* The request returns a list of all disks, specifying which are configured as working storage, cache storage, or
* stored volume or not configured at all. The response includes a DiskStatus field. This field can
* have a value of present (the disk is available to use), missing (the disk is no longer connected to the gateway),
* or mismatch (the disk node is occupied by a disk that has incorrect metadata or the disk content is corrupted).
*
*
* @param listLocalDisksRequest
* A JSON object containing the Amazon Resource Name (ARN) of the gateway.
* @return Result of the ListLocalDisks operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListLocalDisks
* @see AWS
* API Documentation
*/
@Override
public ListLocalDisksResult listLocalDisks(ListLocalDisksRequest request) {
request = beforeClientExecution(request);
return executeListLocalDisks(request);
}
@SdkInternalApi
final ListLocalDisksResult executeListLocalDisks(ListLocalDisksRequest listLocalDisksRequest) {
ExecutionContext executionContext = createExecutionContext(listLocalDisksRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListLocalDisksRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listLocalDisksRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListLocalDisks");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListLocalDisksResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the tags that have been added to the specified resource. This operation is supported in storage gateways of
* all types.
*
*
* @param listTagsForResourceRequest
* ListTagsForResourceInput
* @return Result of the ListTagsForResource operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.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, "Storage Gateway");
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);
}
}
@Override
public ListTagsForResourceResult listTagsForResource() {
return listTagsForResource(new ListTagsForResourceRequest());
}
/**
*
* Lists custom tape pools. You specify custom tape pools to list by specifying one or more custom tape pool Amazon
* Resource Names (ARNs). If you don't specify a custom tape pool ARN, the operation lists all custom tape pools.
*
*
* This operation supports pagination. You can optionally specify the Limit parameter in the body to
* limit the number of tape pools in the response. If the number of tape pools returned in the response is
* truncated, the response includes a Marker element that you can use in your subsequent request to
* retrieve the next set of tape pools.
*
*
* @param listTapePoolsRequest
* @return Result of the ListTapePools operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListTapePools
* @see AWS
* API Documentation
*/
@Override
public ListTapePoolsResult listTapePools(ListTapePoolsRequest request) {
request = beforeClientExecution(request);
return executeListTapePools(request);
}
@SdkInternalApi
final ListTapePoolsResult executeListTapePools(ListTapePoolsRequest listTapePoolsRequest) {
ExecutionContext executionContext = createExecutionContext(listTapePoolsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTapePoolsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTapePoolsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTapePools");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTapePoolsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists virtual tapes in your virtual tape library (VTL) and your virtual tape shelf (VTS). You specify the tapes
* to list by specifying one or more tape Amazon Resource Names (ARNs). If you don't specify a tape ARN, the
* operation lists all virtual tapes in both your VTL and VTS.
*
*
* This operation supports pagination. By default, the operation returns a maximum of up to 100 tapes. You can
* optionally specify the Limit parameter in the body to limit the number of tapes in the response. If
* the number of tapes returned in the response is truncated, the response includes a Marker element
* that you can use in your subsequent request to retrieve the next set of tapes. This operation is only supported
* in the tape gateway type.
*
*
* @param listTapesRequest
* A JSON object that contains one or more of the following fields:
*
* -
*
*
* -
*
*
* -
*
*
* @return Result of the ListTapes operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListTapes
* @see AWS API
* Documentation
*/
@Override
public ListTapesResult listTapes(ListTapesRequest request) {
request = beforeClientExecution(request);
return executeListTapes(request);
}
@SdkInternalApi
final ListTapesResult executeListTapes(ListTapesRequest listTapesRequest) {
ExecutionContext executionContext = createExecutionContext(listTapesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTapesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTapesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTapes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTapesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists iSCSI initiators that are connected to a volume. You can use this operation to determine whether a volume
* is being used or not. This operation is only supported in the cached volume and stored volume gateway types.
*
*
* @param listVolumeInitiatorsRequest
* ListVolumeInitiatorsInput
* @return Result of the ListVolumeInitiators operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListVolumeInitiators
* @see AWS API Documentation
*/
@Override
public ListVolumeInitiatorsResult listVolumeInitiators(ListVolumeInitiatorsRequest request) {
request = beforeClientExecution(request);
return executeListVolumeInitiators(request);
}
@SdkInternalApi
final ListVolumeInitiatorsResult executeListVolumeInitiators(ListVolumeInitiatorsRequest listVolumeInitiatorsRequest) {
ExecutionContext executionContext = createExecutionContext(listVolumeInitiatorsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListVolumeInitiatorsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listVolumeInitiatorsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListVolumeInitiators");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListVolumeInitiatorsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the recovery points for a specified gateway. This operation is only supported in the cached volume gateway
* type.
*
*
* Each cache volume has one recovery point. A volume recovery point is a point in time at which all data of the
* volume is consistent and from which you can create a snapshot or clone a new cached volume from a source volume.
* To create a snapshot from a volume recovery point use the CreateSnapshotFromVolumeRecoveryPoint operation.
*
*
* @param listVolumeRecoveryPointsRequest
* @return Result of the ListVolumeRecoveryPoints operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListVolumeRecoveryPoints
* @see AWS API Documentation
*/
@Override
public ListVolumeRecoveryPointsResult listVolumeRecoveryPoints(ListVolumeRecoveryPointsRequest request) {
request = beforeClientExecution(request);
return executeListVolumeRecoveryPoints(request);
}
@SdkInternalApi
final ListVolumeRecoveryPointsResult executeListVolumeRecoveryPoints(ListVolumeRecoveryPointsRequest listVolumeRecoveryPointsRequest) {
ExecutionContext executionContext = createExecutionContext(listVolumeRecoveryPointsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListVolumeRecoveryPointsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listVolumeRecoveryPointsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListVolumeRecoveryPoints");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListVolumeRecoveryPointsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the iSCSI stored volumes of a gateway. Results are sorted by volume ARN. The response includes only the
* volume ARNs. If you want additional volume information, use the DescribeStorediSCSIVolumes or the
* DescribeCachediSCSIVolumes API.
*
*
* The operation supports pagination. By default, the operation returns a maximum of up to 100 volumes. You can
* optionally specify the Limit field in the body to limit the number of volumes in the response. If
* the number of volumes returned in the response is truncated, the response includes a Marker field. You can use
* this Marker value in your subsequent request to retrieve the next set of volumes. This operation is only
* supported in the cached volume and stored volume gateway types.
*
*
* @param listVolumesRequest
* A JSON object that contains one or more of the following fields:
*
* -
*
*
* -
*
*
* @return Result of the ListVolumes operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ListVolumes
* @see AWS API
* Documentation
*/
@Override
public ListVolumesResult listVolumes(ListVolumesRequest request) {
request = beforeClientExecution(request);
return executeListVolumes(request);
}
@SdkInternalApi
final ListVolumesResult executeListVolumes(ListVolumesRequest listVolumesRequest) {
ExecutionContext executionContext = createExecutionContext(listVolumesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListVolumesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listVolumesRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListVolumes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListVolumesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sends you notification through CloudWatch Events when all files written to your file share have been uploaded to
* S3. Amazon S3.
*
*
* Storage Gateway can send a notification through Amazon CloudWatch Events when all files written to your file
* share up to that point in time have been uploaded to Amazon S3. These files include files written to the file
* share up to the time that you make a request for notification. When the upload is done, Storage Gateway sends you
* notification through an Amazon CloudWatch Event. You can configure CloudWatch Events to send the notification
* through event targets such as Amazon SNS or Lambda function. This operation is only supported for S3 File
* Gateways.
*
*
* For more information, see Getting file upload notification in the Storage Gateway User Guide.
*
*
* @param notifyWhenUploadedRequest
* @return Result of the NotifyWhenUploaded operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.NotifyWhenUploaded
* @see AWS API Documentation
*/
@Override
public NotifyWhenUploadedResult notifyWhenUploaded(NotifyWhenUploadedRequest request) {
request = beforeClientExecution(request);
return executeNotifyWhenUploaded(request);
}
@SdkInternalApi
final NotifyWhenUploadedResult executeNotifyWhenUploaded(NotifyWhenUploadedRequest notifyWhenUploadedRequest) {
ExecutionContext executionContext = createExecutionContext(notifyWhenUploadedRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new NotifyWhenUploadedRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(notifyWhenUploadedRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "NotifyWhenUploaded");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new NotifyWhenUploadedResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Refreshes the cached inventory of objects for the specified file share. This operation finds objects in the
* Amazon S3 bucket that were added, removed, or replaced since the gateway last listed the bucket's contents and
* cached the results. This operation does not import files into the S3 File Gateway cache storage. It only updates
* the cached inventory to reflect changes in the inventory of the objects in the S3 bucket. This operation is only
* supported in the S3 File Gateway types.
*
*
* You can subscribe to be notified through an Amazon CloudWatch event when your RefreshCache operation
* completes. For more information, see Getting notified about file operations in the Storage Gateway User Guide. This operation is Only
* supported for S3 File Gateways.
*
*
* When this API is called, it only initiates the refresh operation. When the API call completes and returns a
* success code, it doesn't necessarily mean that the file refresh has completed. You should use the
* refresh-complete notification to determine that the operation has completed before you check for new files on the
* gateway file share. You can subscribe to be notified through a CloudWatch event when your
* RefreshCache operation completes.
*
*
* Throttle limit: This API is asynchronous, so the gateway will accept no more than two refreshes at any time. We
* recommend using the refresh-complete CloudWatch event notification before issuing additional requests. For more
* information, see Getting notified about file operations in the Storage Gateway User Guide.
*
*
*
* -
*
* Wait at least 60 seconds between consecutive RefreshCache API requests.
*
*
* -
*
* RefreshCache does not evict cache entries if invoked consecutively within 60 seconds of a previous RefreshCache
* request.
*
*
* -
*
* If you invoke the RefreshCache API when two requests are already being processed, any new request will cause an
* InvalidGatewayRequestException error because too many requests were sent to the server.
*
*
*
*
*
* The S3 bucket name does not need to be included when entering the list of folders in the FolderList parameter.
*
*
*
* For more information, see Getting notified about file operations in the Storage Gateway User Guide.
*
*
* @param refreshCacheRequest
* RefreshCacheInput
* @return Result of the RefreshCache operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.RefreshCache
* @see AWS
* API Documentation
*/
@Override
public RefreshCacheResult refreshCache(RefreshCacheRequest request) {
request = beforeClientExecution(request);
return executeRefreshCache(request);
}
@SdkInternalApi
final RefreshCacheResult executeRefreshCache(RefreshCacheRequest refreshCacheRequest) {
ExecutionContext executionContext = createExecutionContext(refreshCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RefreshCacheRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(refreshCacheRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RefreshCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RefreshCacheResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Removes one or more tags from the specified resource. This operation is supported in storage gateways of all
* types.
*
*
* @param removeTagsFromResourceRequest
* RemoveTagsFromResourceInput
* @return Result of the RemoveTagsFromResource operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.RemoveTagsFromResource
* @see AWS API Documentation
*/
@Override
public RemoveTagsFromResourceResult removeTagsFromResource(RemoveTagsFromResourceRequest request) {
request = beforeClientExecution(request);
return executeRemoveTagsFromResource(request);
}
@SdkInternalApi
final RemoveTagsFromResourceResult executeRemoveTagsFromResource(RemoveTagsFromResourceRequest removeTagsFromResourceRequest) {
ExecutionContext executionContext = createExecutionContext(removeTagsFromResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RemoveTagsFromResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(removeTagsFromResourceRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RemoveTagsFromResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RemoveTagsFromResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public RemoveTagsFromResourceResult removeTagsFromResource() {
return removeTagsFromResource(new RemoveTagsFromResourceRequest());
}
/**
*
* Resets all cache disks that have encountered an error and makes the disks available for reconfiguration as cache
* storage. If your cache disk encounters an error, the gateway prevents read and write operations on virtual tapes
* in the gateway. For example, an error can occur when a disk is corrupted or removed from the gateway. When a
* cache is reset, the gateway loses its cache storage. At this point, you can reconfigure the disks as cache disks.
* This operation is only supported in the cached volume and tape types.
*
*
*
* If the cache disk you are resetting contains data that has not been uploaded to Amazon S3 yet, that data can be
* lost. After you reset cache disks, there will be no configured cache disks left in the gateway, so you must
* configure at least one new cache disk for your gateway to function properly.
*
*
*
* @param resetCacheRequest
* @return Result of the ResetCache operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ResetCache
* @see AWS API
* Documentation
*/
@Override
public ResetCacheResult resetCache(ResetCacheRequest request) {
request = beforeClientExecution(request);
return executeResetCache(request);
}
@SdkInternalApi
final ResetCacheResult executeResetCache(ResetCacheRequest resetCacheRequest) {
ExecutionContext executionContext = createExecutionContext(resetCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ResetCacheRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(resetCacheRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ResetCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ResetCacheResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves an archived virtual tape from the virtual tape shelf (VTS) to a tape gateway. Virtual tapes archived in
* the VTS are not associated with any gateway. However after a tape is retrieved, it is associated with a gateway,
* even though it is also listed in the VTS, that is, archive. This operation is only supported in the tape gateway
* type.
*
*
* Once a tape is successfully retrieved to a gateway, it cannot be retrieved again to another gateway. You must
* archive the tape again before you can retrieve it to another gateway. This operation is only supported in the
* tape gateway type.
*
*
* @param retrieveTapeArchiveRequest
* RetrieveTapeArchiveInput
* @return Result of the RetrieveTapeArchive operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.RetrieveTapeArchive
* @see AWS API Documentation
*/
@Override
public RetrieveTapeArchiveResult retrieveTapeArchive(RetrieveTapeArchiveRequest request) {
request = beforeClientExecution(request);
return executeRetrieveTapeArchive(request);
}
@SdkInternalApi
final RetrieveTapeArchiveResult executeRetrieveTapeArchive(RetrieveTapeArchiveRequest retrieveTapeArchiveRequest) {
ExecutionContext executionContext = createExecutionContext(retrieveTapeArchiveRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RetrieveTapeArchiveRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(retrieveTapeArchiveRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RetrieveTapeArchive");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RetrieveTapeArchiveResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves the recovery point for the specified virtual tape. This operation is only supported in the tape gateway
* type.
*
*
* A recovery point is a point in time view of a virtual tape at which all the data on the tape is consistent. If
* your gateway crashes, virtual tapes that have recovery points can be recovered to a new gateway.
*
*
*
* The virtual tape can be retrieved to only one gateway. The retrieved tape is read-only. The virtual tape can be
* retrieved to only a tape gateway. There is no charge for retrieving recovery points.
*
*
*
* @param retrieveTapeRecoveryPointRequest
* RetrieveTapeRecoveryPointInput
* @return Result of the RetrieveTapeRecoveryPoint operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.RetrieveTapeRecoveryPoint
* @see AWS API Documentation
*/
@Override
public RetrieveTapeRecoveryPointResult retrieveTapeRecoveryPoint(RetrieveTapeRecoveryPointRequest request) {
request = beforeClientExecution(request);
return executeRetrieveTapeRecoveryPoint(request);
}
@SdkInternalApi
final RetrieveTapeRecoveryPointResult executeRetrieveTapeRecoveryPoint(RetrieveTapeRecoveryPointRequest retrieveTapeRecoveryPointRequest) {
ExecutionContext executionContext = createExecutionContext(retrieveTapeRecoveryPointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RetrieveTapeRecoveryPointRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(retrieveTapeRecoveryPointRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RetrieveTapeRecoveryPoint");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RetrieveTapeRecoveryPointResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets the password for your VM local console. When you log in to the local console for the first time, you log in
* to the VM with the default credentials. We recommend that you set a new password. You don't need to know the
* default password to set a new password.
*
*
* @param setLocalConsolePasswordRequest
* SetLocalConsolePasswordInput
* @return Result of the SetLocalConsolePassword operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.SetLocalConsolePassword
* @see AWS API Documentation
*/
@Override
public SetLocalConsolePasswordResult setLocalConsolePassword(SetLocalConsolePasswordRequest request) {
request = beforeClientExecution(request);
return executeSetLocalConsolePassword(request);
}
@SdkInternalApi
final SetLocalConsolePasswordResult executeSetLocalConsolePassword(SetLocalConsolePasswordRequest setLocalConsolePasswordRequest) {
ExecutionContext executionContext = createExecutionContext(setLocalConsolePasswordRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetLocalConsolePasswordRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(setLocalConsolePasswordRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetLocalConsolePassword");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new SetLocalConsolePasswordResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets the password for the guest user smbguest. The smbguest user is the user when the
* authentication method for the file share is set to GuestAccess. This operation only supported for S3
* File Gateways
*
*
* @param setSMBGuestPasswordRequest
* SetSMBGuestPasswordInput
* @return Result of the SetSMBGuestPassword operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.SetSMBGuestPassword
* @see AWS API Documentation
*/
@Override
public SetSMBGuestPasswordResult setSMBGuestPassword(SetSMBGuestPasswordRequest request) {
request = beforeClientExecution(request);
return executeSetSMBGuestPassword(request);
}
@SdkInternalApi
final SetSMBGuestPasswordResult executeSetSMBGuestPassword(SetSMBGuestPasswordRequest setSMBGuestPasswordRequest) {
ExecutionContext executionContext = createExecutionContext(setSMBGuestPasswordRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetSMBGuestPasswordRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(setSMBGuestPasswordRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetSMBGuestPassword");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new SetSMBGuestPasswordResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Shuts down a gateway. To specify which gateway to shut down, use the Amazon Resource Name (ARN) of the gateway in
* the body of your request.
*
*
* The operation shuts down the gateway service component running in the gateway's virtual machine (VM) and not the
* host VM.
*
*
*
* If you want to shut down the VM, it is recommended that you first shut down the gateway component in the VM to
* avoid unpredictable conditions.
*
*
*
* After the gateway is shutdown, you cannot call any other API except StartGateway,
* DescribeGatewayInformation, and ListGateways. For more information, see ActivateGateway.
* Your applications cannot read from or write to the gateway's storage volumes, and there are no snapshots taken.
*
*
*
* When you make a shutdown request, you will get a 200 OK success response immediately. However, it
* might take some time for the gateway to shut down. You can call the DescribeGatewayInformation API to
* check the status. For more information, see ActivateGateway.
*
*
*
* If do not intend to use the gateway again, you must delete the gateway (using DeleteGateway) to no longer
* pay software charges associated with the gateway.
*
*
* @param shutdownGatewayRequest
* A JSON object containing the Amazon Resource Name (ARN) of the gateway to shut down.
* @return Result of the ShutdownGateway operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.ShutdownGateway
* @see AWS
* API Documentation
*/
@Override
public ShutdownGatewayResult shutdownGateway(ShutdownGatewayRequest request) {
request = beforeClientExecution(request);
return executeShutdownGateway(request);
}
@SdkInternalApi
final ShutdownGatewayResult executeShutdownGateway(ShutdownGatewayRequest shutdownGatewayRequest) {
ExecutionContext executionContext = createExecutionContext(shutdownGatewayRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ShutdownGatewayRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(shutdownGatewayRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ShutdownGateway");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ShutdownGatewayResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Start a test that verifies that the specified gateway is configured for High Availability monitoring in your host
* environment. This request only initiates the test and that a successful response only indicates that the test was
* started. It doesn't indicate that the test passed. For the status of the test, invoke the
* DescribeAvailabilityMonitorTest API.
*
*
*
* Starting this test will cause your gateway to go offline for a brief period.
*
*
*
* @param startAvailabilityMonitorTestRequest
* @return Result of the StartAvailabilityMonitorTest operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.StartAvailabilityMonitorTest
* @see AWS API Documentation
*/
@Override
public StartAvailabilityMonitorTestResult startAvailabilityMonitorTest(StartAvailabilityMonitorTestRequest request) {
request = beforeClientExecution(request);
return executeStartAvailabilityMonitorTest(request);
}
@SdkInternalApi
final StartAvailabilityMonitorTestResult executeStartAvailabilityMonitorTest(StartAvailabilityMonitorTestRequest startAvailabilityMonitorTestRequest) {
ExecutionContext executionContext = createExecutionContext(startAvailabilityMonitorTestRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartAvailabilityMonitorTestRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(startAvailabilityMonitorTestRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartAvailabilityMonitorTest");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new StartAvailabilityMonitorTestResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Starts a gateway that you previously shut down (see ShutdownGateway). After the gateway starts, you can
* then make other API calls, your applications can read from or write to the gateway's storage volumes and you will
* be able to take snapshot backups.
*
*
*
* When you make a request, you will get a 200 OK success response immediately. However, it might take some time for
* the gateway to be ready. You should call DescribeGatewayInformation and check the status before making any
* additional API calls. For more information, see ActivateGateway.
*
*
*
* To specify which gateway to start, use the Amazon Resource Name (ARN) of the gateway in your request.
*
*
* @param startGatewayRequest
* A JSON object containing the Amazon Resource Name (ARN) of the gateway to start.
* @return Result of the StartGateway operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.StartGateway
* @see AWS
* API Documentation
*/
@Override
public StartGatewayResult startGateway(StartGatewayRequest request) {
request = beforeClientExecution(request);
return executeStartGateway(request);
}
@SdkInternalApi
final StartGatewayResult executeStartGateway(StartGatewayRequest startGatewayRequest) {
ExecutionContext executionContext = createExecutionContext(startGatewayRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartGatewayRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(startGatewayRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartGateway");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new StartGatewayResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the automatic tape creation policy of a gateway. Use this to update the policy with a new set of
* automatic tape creation rules. This is only supported for tape gateways.
*
*
* By default, there is no automatic tape creation policy.
*
*
*
* A gateway can have only one automatic tape creation policy.
*
*
*
* @param updateAutomaticTapeCreationPolicyRequest
* @return Result of the UpdateAutomaticTapeCreationPolicy operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.UpdateAutomaticTapeCreationPolicy
* @see AWS API Documentation
*/
@Override
public UpdateAutomaticTapeCreationPolicyResult updateAutomaticTapeCreationPolicy(UpdateAutomaticTapeCreationPolicyRequest request) {
request = beforeClientExecution(request);
return executeUpdateAutomaticTapeCreationPolicy(request);
}
@SdkInternalApi
final UpdateAutomaticTapeCreationPolicyResult executeUpdateAutomaticTapeCreationPolicy(
UpdateAutomaticTapeCreationPolicyRequest updateAutomaticTapeCreationPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(updateAutomaticTapeCreationPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateAutomaticTapeCreationPolicyRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateAutomaticTapeCreationPolicyRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateAutomaticTapeCreationPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateAutomaticTapeCreationPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the bandwidth rate limits of a gateway. You can update both the upload and download bandwidth rate limit
* or specify only one of the two. If you don't set a bandwidth rate limit, the existing rate limit remains. This
* operation is supported only for the stored volume, cached volume, and tape gateway types. To update bandwidth
* rate limits for S3 file gateways, use UpdateBandwidthRateLimitSchedule.
*
*
* By default, a gateway's bandwidth rate limits are not set. If you don't set any limit, the gateway does not have
* any limitations on its bandwidth usage and could potentially use the maximum available bandwidth.
*
*
* To specify which gateway to update, use the Amazon Resource Name (ARN) of the gateway in your request.
*
*
* @param updateBandwidthRateLimitRequest
* A JSON object containing one or more of the following fields:
*
* -
*
* UpdateBandwidthRateLimitInput$AverageDownloadRateLimitInBitsPerSec
*
*
* -
*
* UpdateBandwidthRateLimitInput$AverageUploadRateLimitInBitsPerSec
*
*
* @return Result of the UpdateBandwidthRateLimit operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.UpdateBandwidthRateLimit
* @see AWS API Documentation
*/
@Override
public UpdateBandwidthRateLimitResult updateBandwidthRateLimit(UpdateBandwidthRateLimitRequest request) {
request = beforeClientExecution(request);
return executeUpdateBandwidthRateLimit(request);
}
@SdkInternalApi
final UpdateBandwidthRateLimitResult executeUpdateBandwidthRateLimit(UpdateBandwidthRateLimitRequest updateBandwidthRateLimitRequest) {
ExecutionContext executionContext = createExecutionContext(updateBandwidthRateLimitRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateBandwidthRateLimitRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateBandwidthRateLimitRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateBandwidthRateLimit");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateBandwidthRateLimitResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the bandwidth rate limit schedule for a specified gateway. By default, gateways do not have bandwidth
* rate limit schedules, which means no bandwidth rate limiting is in effect. Use this to initiate or update a
* gateway's bandwidth rate limit schedule. This operation is supported only for volume, tape and S3 file gateways.
* FSx file gateways do not support bandwidth rate limits.
*
*
* @param updateBandwidthRateLimitScheduleRequest
* @return Result of the UpdateBandwidthRateLimitSchedule operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.UpdateBandwidthRateLimitSchedule
* @see AWS API Documentation
*/
@Override
public UpdateBandwidthRateLimitScheduleResult updateBandwidthRateLimitSchedule(UpdateBandwidthRateLimitScheduleRequest request) {
request = beforeClientExecution(request);
return executeUpdateBandwidthRateLimitSchedule(request);
}
@SdkInternalApi
final UpdateBandwidthRateLimitScheduleResult executeUpdateBandwidthRateLimitSchedule(
UpdateBandwidthRateLimitScheduleRequest updateBandwidthRateLimitScheduleRequest) {
ExecutionContext executionContext = createExecutionContext(updateBandwidthRateLimitScheduleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateBandwidthRateLimitScheduleRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateBandwidthRateLimitScheduleRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateBandwidthRateLimitSchedule");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateBandwidthRateLimitScheduleResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the Challenge-Handshake Authentication Protocol (CHAP) credentials for a specified iSCSI target. By
* default, a gateway does not have CHAP enabled; however, for added security, you might use it. This operation is
* supported in the volume and tape gateway types.
*
*
*
* When you update CHAP credentials, all existing connections on the target are closed and initiators must reconnect
* with the new credentials.
*
*
*
* @param updateChapCredentialsRequest
* A JSON object containing one or more of the following fields:
*
* -
*
*
* -
*
* UpdateChapCredentialsInput$SecretToAuthenticateInitiator
*
*
* -
*
*
* -
*
*
* @return Result of the UpdateChapCredentials operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.UpdateChapCredentials
* @see AWS API Documentation
*/
@Override
public UpdateChapCredentialsResult updateChapCredentials(UpdateChapCredentialsRequest request) {
request = beforeClientExecution(request);
return executeUpdateChapCredentials(request);
}
@SdkInternalApi
final UpdateChapCredentialsResult executeUpdateChapCredentials(UpdateChapCredentialsRequest updateChapCredentialsRequest) {
ExecutionContext executionContext = createExecutionContext(updateChapCredentialsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateChapCredentialsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateChapCredentialsRequest));
// 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, "Storage Gateway");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateChapCredentials");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateChapCredentialsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a file system association. This operation is only supported in the FSx File Gateways.
*
*
* @param updateFileSystemAssociationRequest
* @return Result of the UpdateFileSystemAssociation operation returned by the service.
* @throws InvalidGatewayRequestException
* An exception occurred because an invalid gateway request was issued to the service. For more information,
* see the error and message fields.
* @throws InternalServerErrorException
* An internal server error has occurred during the request. For more information, see the error and message
* fields.
* @sample AWSStorageGateway.UpdateFileSystemAssociation
* @see AWS API Documentation
*/
@Override
public UpdateFileSystemAssociationResult updateFileSystemAssociation(UpdateFileSystemAssociationRequest request) {
request = beforeClientExecution(request);
return executeUpdateFileSystemAssociation(request);
}
@SdkInternalApi
final UpdateFileSystemAssociationResult executeUpdateFileSystemAssociation(UpdateFileSystemAssociationRequest updateFileSystemAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(updateFileSystemAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response