com.amazonaws.services.storagegateway.AWSStorageGatewayClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-osgi Show documentation
/*
* Copyright 2011-2016 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 java.util.Map.Entry;
import org.apache.commons.logging.*;
import com.amazonaws.*;
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.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.
*
* AWS Storage Gateway Service
*
* AWS 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 AWS's storage
* infrastructure. The service enables you to securely upload data to the AWS
* cloud for cost effective backup and rapid disaster recovery.
*
*
* Use the following links to get started using the AWS Storage Gateway
* Service API Reference:
*
*
* -
*
* AWS Storage Gateway Required Request Headers: Describes the required
* headers that you must send with every POST request to AWS Storage Gateway.
*
*
* -
*
* Signing Requests: AWS Storage Gateway requires that you authenticate
* every request you send; this topic describes how sign such a request.
*
*
* -
*
* Error Responses: Provides reference information about AWS Storage
* Gateway errors.
*
*
* -
*
* Operations in AWS Storage Gateway: Contains detailed descriptions of all
* AWS Storage Gateway operations, their request parameters, response elements,
* possible errors, and examples of requests and responses.
*
*
* -
*
*
* AWS Storage Gateway Regions and Endpoints: Provides a list of each of the
* s and endpoints available for use with AWS Storage Gateway.
*
*
*
*
*
* AWS 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-1122AABB. When you use this ID with the EC2 API, you must
* change it to vol-1122aabb. 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 ARN with the longer volume ID format will look like
* this:
*
*
* arn:aws:storagegateway:us-west-2:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABBCCDDEEFFG
* .
*
*
* A snapshot ID with the longer ID format will look like this:
* snap-78e226633445566ee.
*
*
* For more information, see Announcement:
* Heads-up – Longer AWS Storage Gateway volume and snapshot IDs coming in
* 2016.
*
*
*/
@ThreadSafe
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 SdkJsonProtocolFactory protocolFactory = new SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode(
"InvalidGatewayRequestException")
.withModeledClass(
com.amazonaws.services.storagegateway.model.InvalidGatewayRequestException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode("InternalServerError")
.withModeledClass(
com.amazonaws.services.storagegateway.model.InternalServerErrorException.class))
.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
*/
public AWSStorageGatewayClient() {
this(new DefaultAWSCredentialsProviderChain(), 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
*/
public AWSStorageGatewayClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), 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.
*/
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.).
*/
public AWSStorageGatewayClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(
awsCredentials);
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.
*/
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.).
*/
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
*/
public AWSStorageGatewayClient(
AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
/**
* 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) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
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"));
}
/**
*
* Activates the gateway you previously deployed on your host. For more
* information, see Activate the AWS Storage Gateway. In the activation process, you
* specify information such as the you want to use for storing snapshots,
* 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
*/
@Override
public ActivateGatewayResult activateGateway(
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 ActivateGatewayRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(activateGatewayRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 cached-volume
* gateway. This operation is supported only for the gateway-cached volume
* architecture (see Storage Gateway Concepts).
*
*
* 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
*/
@Override
public AddCacheResult addCache(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 AddCacheRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(addCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 AWS Storage Gateway resources:
*
*
* -
*
* Storage gateways of all types
*
*
*
*
* -
*
* Storage Volumes
*
*
*
*
* -
*
* Virtual Tapes
*
*
*
*
* You can create a maximum of 10 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
*/
@Override
public AddTagsToResourceResult addTagsToResource(
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 AddTagsToResourceRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(addTagsToResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 both the
* gateway-stored and gateway-cached volume architectures.
*
*
* 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
*/
@Override
public AddUploadBufferResult addUploadBuffer(
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 AddUploadBufferRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(addUploadBufferRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 supported only for the gateway-stored volume
* architecture. This operation is deprecated in cached-volumes 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
*/
@Override
public AddWorkingStorageResult addWorkingStorage(
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 AddWorkingStorageRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(addWorkingStorageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* Cancels archiving of a virtual tape to the virtual tape shelf (VTS) after
* the archiving process is initiated.
*
*
* @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
*/
@Override
public CancelArchivalResult cancelArchival(
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 CancelArchivalRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(cancelArchivalRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
* @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
*/
@Override
public CancelRetrievalResult cancelRetrieval(
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 CancelRetrievalRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(cancelRetrievalRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 gateway. This operation is
* supported only for the gateway-cached volume architecture.
*
*
*
* 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, AWS Storage Gateway
* creates the volume and returns information about it 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 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
*/
@Override
public CreateCachediSCSIVolumeResult createCachediSCSIVolume(
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 CreateCachediSCSIVolumeRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(createCachediSCSIVolumeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* Initiates a snapshot of a volume.
*
*
* AWS Storage Gateway provides the ability to back up point-in-time
* snapshots of your data to Amazon Simple Storage (S3) for durable off-site
* recovery, as well as 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 ad-hoc snapshot. For more information, see Working With Snapshots in the AWS Storage Gateway Console.
*
*
* In the CreateSnapshot request you identify the volume by providing its
* Amazon Resource Name (ARN). You must also provide description for the
* snapshot. When AWS Storage Gateway takes the snapshot of specified
* volume, the snapshot and description appears in the AWS Storage Gateway
* Console. In response, AWS 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.
*
*
*
* To list or delete a snapshot, you must use the Amazon EC2 API. For more
* information, see DescribeSnapshots or DeleteSnapshot in the EC2 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.
* @sample AWSStorageGateway.CreateSnapshot
*/
@Override
public CreateSnapshotResult createSnapshot(
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 CreateSnapshotRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(createSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 supported only for the gateway-cached volume architecture.
*
*
* 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 gateway-cached volumes, 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 AWS Storage Gateway
* takes a snapshot of the specified volume, the snapshot and its
* description appear in the AWS Storage Gateway console. In response, AWS
* 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.
*
*
*
* To list or delete a snapshot, you must use the Amazon EC2 API. For more
* information, in 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.
* @sample AWSStorageGateway.CreateSnapshotFromVolumeRecoveryPoint
*/
@Override
public CreateSnapshotFromVolumeRecoveryPointResult createSnapshotFromVolumeRecoveryPoint(
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 CreateSnapshotFromVolumeRecoveryPointRequestMarshaller(
protocolFactory)
.marshall(super
.beforeMarshalling(createSnapshotFromVolumeRecoveryPointRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 supported only
* for the gateway-stored volume architecture.
*
*
* 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, AWS Storage 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
*/
@Override
public CreateStorediSCSIVolumeResult createStorediSCSIVolume(
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 CreateStorediSCSIVolumeRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(createStorediSCSIVolumeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 virtual tape by using your own barcode. You write data to the
* virtual tape and then archive the tape.
*
*
*
* 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
*/
@Override
public CreateTapeWithBarcodeResult createTapeWithBarcode(
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 CreateTapeWithBarcodeRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(createTapeWithBarcodeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
*
* 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
*/
@Override
public CreateTapesResult createTapes(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 CreateTapesRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(createTapesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 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.
*
*
* @param deleteBandwidthRateLimitRequest
* @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
*/
@Override
public DeleteBandwidthRateLimitResult deleteBandwidthRateLimit(
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 DeleteBandwidthRateLimitRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(deleteBandwidthRateLimitRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
* @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
*/
@Override
public DeleteChapCredentialsResult deleteChapCredentials(
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 DeleteChapCredentialsRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(deleteChapCredentialsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 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 AWS 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
*/
@Override
public DeleteGatewayResult deleteGateway(
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 DeleteGatewayRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(deleteGatewayRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 Working with Snapshots. In the DeleteSnapshotSchedule
* request, you identify the volume by providing its Amazon Resource Name
* (ARN).
*
*
*
* To list or delete a snapshot, you must use the Amazon EC2 API. in
* 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
*/
@Override
public DeleteSnapshotScheduleResult deleteSnapshotSchedule(
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 DeleteSnapshotScheduleRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(deleteSnapshotScheduleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
* @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
*/
@Override
public DeleteTapeResult deleteTape(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 DeleteTapeRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(deleteTapeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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).
*
*
* @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
*/
@Override
public DeleteTapeArchiveResult deleteTapeArchive(
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 DeleteTapeArchiveRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(deleteTapeArchiveRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* Deletes the specified gateway volume that you previously created using
* the CreateCachediSCSIVolume or CreateStorediSCSIVolume API.
* For gateway-stored volumes, 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 gateway 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
*/
@Override
public DeleteVolumeResult deleteVolume(
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 DeleteVolumeRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(deleteVolumeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new DeleteVolumeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the bandwidth rate limits of a gateway. By default, these limits
* are not set, which means no bandwidth rate limiting is in effect.
*
*
* This operation only 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 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
*/
@Override
public DescribeBandwidthRateLimitResult describeBandwidthRateLimit(
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 DescribeBandwidthRateLimitRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeBandwidthRateLimitRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 cache of a gateway. This operation is
* supported only for the gateway-cached volume architecture.
*
*
* 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
*/
@Override
public DescribeCacheResult describeCache(
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 DescribeCacheRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(describeCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 supported only for the gateway-cached volume
* architecture.
*
*
* The list of gateway volumes in the request must be from one gateway. In
* the response Amazon 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
*/
@Override
public DescribeCachediSCSIVolumesResult describeCachediSCSIVolumes(
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 DescribeCachediSCSIVolumesRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeCachediSCSIVolumesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
* @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
*/
@Override
public DescribeChapCredentialsResult describeChapCredentials(
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 DescribeChapCredentialsRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeChapCredentialsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* 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
*/
@Override
public DescribeGatewayInformationResult describeGatewayInformation(
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 DescribeGatewayInformationRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeGatewayInformationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 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
*/
@Override
public DescribeMaintenanceStartTimeResult describeMaintenanceStartTime(
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 DescribeMaintenanceStartTimeRequestMarshaller(
protocolFactory)
.marshall(super
.beforeMarshalling(describeMaintenanceStartTimeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* Describes the snapshot schedule for the specified gateway volume. The
* snapshot schedule information includes intervals at which snapshots are
* automatically initiated on the volume.
*
*
* @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
*/
@Override
public DescribeSnapshotScheduleResult describeSnapshotSchedule(
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 DescribeSnapshotScheduleRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeSnapshotScheduleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 Amazon Storage Gateway returns volume information sorted by
* volume ARNs.
*
*
* @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
*/
@Override
public DescribeStorediSCSIVolumesResult describeStorediSCSIVolumes(
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 DescribeStorediSCSIVolumesRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeStorediSCSIVolumesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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).
*
*
* If a specific TapeARN is not specified, AWS 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
*/
@Override
public DescribeTapeArchivesResult describeTapeArchives(
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 DescribeTapeArchivesRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeTapeArchivesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 gateway-VTL.
*
*
* 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.
*
*
* @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
*/
@Override
public DescribeTapeRecoveryPointsResult describeTapeRecoveryPoints(
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 DescribeTapeRecoveryPointsRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeTapeRecoveryPointsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
* @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
*/
@Override
public DescribeTapesResult describeTapes(
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 DescribeTapesRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(describeTapesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 both the gateway-stored and gateway-cached volume
* architectures.
*
*
* 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
*/
@Override
public DescribeUploadBufferResult describeUploadBuffer(
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 DescribeUploadBufferRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeUploadBufferRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 gateway. In the response, AWS Storage Gateway returns VTL
* device information.
*
*
* The list of VTL devices must be from one gateway.
*
*
* @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
*/
@Override
public DescribeVTLDevicesResult describeVTLDevices(
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 DescribeVTLDevicesRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeVTLDevicesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 supported only for the gateway-stored volume architecture.
* 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 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
*/
@Override
public DescribeWorkingStorageResult describeWorkingStorage(
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 DescribeWorkingStorageRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(describeWorkingStorageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* Disables a 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 gateway-VTL that is not reachable or not
* functioning.
*
*
*
* Once 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
*/
@Override
public DisableGatewayResult disableGateway(
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 DisableGatewayRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(disableGatewayRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* Lists gateways owned by an AWS account in a 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
*/
@Override
public ListGatewaysResult listGateways(
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 ListGatewaysRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(listGatewaysRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 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
*/
@Override
public ListLocalDisksResult listLocalDisks(
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 ListLocalDisksRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(listLocalDisksRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
* @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
*/
@Override
public ListTagsForResourceResult listTagsForResource(
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 ListTagsForResourceRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(listTagsForResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 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.
*
*
* @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
*/
@Override
public ListTapesResult listTapes(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 ListTapesRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(listTapesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
* @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
*/
@Override
public ListVolumeInitiatorsResult listVolumeInitiators(
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 ListVolumeInitiatorsRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(listVolumeInitiatorsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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
* supported only for the gateway-cached volume architecture.
*
*
* Each gateway-cached 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. 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
*/
@Override
public ListVolumeRecoveryPointsResult listVolumeRecoveryPoints(
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 ListVolumeRecoveryPointsRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(listVolumeRecoveryPointsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 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.
*
*
* @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
*/
@Override
public ListVolumesResult listVolumes(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 ListVolumesRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(listVolumesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* Removes one or more tags from the specified resource.
*
*
* @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
*/
@Override
public RemoveTagsFromResourceResult removeTagsFromResource(
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 RemoveTagsFromResourceRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(removeTagsFromResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 a error and makes the disks
* available for reconfiguration as cache storage. If your cache disk
* encounters a 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.
*
*
*
* 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
*/
@Override
public ResetCacheResult resetCache(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 ResetCacheRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(resetCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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
* gateway-VTL. 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.
*
*
* 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.
*
*
* @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
*/
@Override
public RetrieveTapeArchiveResult retrieveTapeArchive(
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 RetrieveTapeArchiveRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(retrieveTapeArchiveRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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.
*
*
* 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 gateway-VTL.
* 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
*/
@Override
public RetrieveTapeRecoveryPointResult retrieveTapeRecoveryPoint(
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 RetrieveTapeRecoveryPointRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(retrieveTapeRecoveryPointRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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
*/
@Override
public SetLocalConsolePasswordResult setLocalConsolePassword(
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 SetLocalConsolePasswordRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(setLocalConsolePasswordRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* 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
* storage gateway's virtual machine (VM) and not the 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 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
*/
@Override
public ShutdownGatewayResult shutdownGateway(
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 ShutdownGatewayRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(shutdownGatewayRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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);
}
}
/**
*
* 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 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
*/
@Override
public StartGatewayResult startGateway(
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 StartGatewayRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(startGatewayRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 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.
*
*
* 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
*/
@Override
public UpdateBandwidthRateLimitResult updateBandwidthRateLimit(
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 UpdateBandwidthRateLimitRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(updateBandwidthRateLimitRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 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.
*
*
*
* 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
*/
@Override
public UpdateChapCredentialsResult updateChapCredentials(
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 UpdateChapCredentialsRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(updateChapCredentialsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} 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 gateway's metadata, which includes the gateway's name and time
* zone. To specify which gateway to update, use the Amazon Resource Name
* (ARN) of the gateway in your request.
*
*
*
* For Gateways activated after September 2, 2015, the gateway's ARN
* contains the gateway ID rather than the gateway name. However, changing
* the name of the gateway has no effect on the gateway's ARN.
*
*
*
* @param updateGatewayInformationRequest
* @return Result of the UpdateGatewayInformation 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.UpdateGatewayInformation
*/
@Override
public UpdateGatewayInformationResult updateGatewayInformation(
UpdateGatewayInformationRequest updateGatewayInformationRequest) {
ExecutionContext executionContext = createExecutionContext(updateGatewayInformationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateGatewayInformationRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(updateGatewayInformationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new UpdateGatewayInformationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the gateway virtual machine (VM) software. The request
* immediately triggers the software update.
*
*
*
* When you make this request, you get a 200 OK success
* response immediately. However, it might take some time for the update to
* complete. You can call DescribeGatewayInformation to verify the
* gateway is in the STATE_RUNNING state.
*
*
*
* A software update forces a system restart of your gateway. You can
* minimize the chance of any disruption to your applications by increasing
* your iSCSI Initiators' timeouts. For more information about increasing
* iSCSI Initiator timeouts for Windows and Linux, see Customizing Your Windows iSCSI Settings and Customizing Your Linux iSCSI Settings, respectively.
*
*
*
* @param updateGatewaySoftwareNowRequest
* A JSON object containing the of the gateway to update.
* @return Result of the UpdateGatewaySoftwareNow 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.UpdateGatewaySoftwareNow
*/
@Override
public UpdateGatewaySoftwareNowResult updateGatewaySoftwareNow(
UpdateGatewaySoftwareNowRequest updateGatewaySoftwareNowRequest) {
ExecutionContext executionContext = createExecutionContext(updateGatewaySoftwareNowRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateGatewaySoftwareNowRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(updateGatewaySoftwareNowRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new UpdateGatewaySoftwareNowResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a gateway's weekly maintenance start time information, including
* day and time of the week. The maintenance time is the time in your
* gateway's time zone.
*
*
* @param updateMaintenanceStartTimeRequest
* A JSON object containing the following fields:
*
* -
*
*
* -
*
*
* -
*
*
* @return Result of the UpdateMaintenanceStartTime 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.UpdateMaintenanceStartTime
*/
@Override
public UpdateMaintenanceStartTimeResult updateMaintenanceStartTime(
UpdateMaintenanceStartTimeRequest updateMaintenanceStartTimeRequest) {
ExecutionContext executionContext = createExecutionContext(updateMaintenanceStartTimeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateMaintenanceStartTimeRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(updateMaintenanceStartTimeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new UpdateMaintenanceStartTimeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a snapshot schedule configured for a gateway volume.
*
*
* The default snapshot schedule for volume is once every 24 hours, starting
* at the creation time of the volume. You can use this API to change the
* snapshot schedule configured for the volume.
*
*
* In the request you must identify the gateway volume whose snapshot
* schedule you want to update, and the schedule information, including when
* you want the snapshot to begin on a day and the frequency (in hours) of
* snapshots.
*
*
* @param updateSnapshotScheduleRequest
* A JSON object containing one or more of the following fields:
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* @return Result of the UpdateSnapshotSchedule 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.UpdateSnapshotSchedule
*/
@Override
public UpdateSnapshotScheduleResult updateSnapshotSchedule(
UpdateSnapshotScheduleRequest updateSnapshotScheduleRequest) {
ExecutionContext executionContext = createExecutionContext(updateSnapshotScheduleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateSnapshotScheduleRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(updateSnapshotScheduleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new UpdateSnapshotScheduleResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the type of medium changer in a gateway-VTL. When you activate a
* gateway-VTL, you select a medium changer type for the gateway-VTL. This
* operation enables you to select a different type of medium changer after
* a gateway-VTL is activated.
*
*
* @param updateVTLDeviceTypeRequest
* @return Result of the UpdateVTLDeviceType 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.UpdateVTLDeviceType
*/
@Override
public UpdateVTLDeviceTypeResult updateVTLDeviceType(
UpdateVTLDeviceTypeRequest updateVTLDeviceTypeRequest) {
ExecutionContext executionContext = createExecutionContext(updateVTLDeviceTypeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateVTLDeviceTypeRequestMarshaller(
protocolFactory).marshall(super
.beforeMarshalling(updateVTLDeviceTypeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new UpdateVTLDeviceTypeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful,
* request, typically used for debugging issues where a service isn't acting
* as expected. This data isn't considered part of the result data returned
* by an operation, so it's available through this separate, diagnostic
* interface.
*
* Response metadata is only cached for a limited period of time, so if you
* need to access this extra diagnostic information for an executed request,
* you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none
* is available.
*/
public ResponseMetadata getCachedResponseMetadata(
AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be
* overriden at the request level.
**/
private Response invoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
executionContext.setCredentialsProvider(CredentialUtils
.getCredentialsProvider(request.getOriginalRequest(),
awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke with no authentication. Credentials are not required and any
* credentials set on the client or request will be ignored for this
* operation.
**/
private Response anonymousInvoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack
* thereof) have been configured in the ExecutionContext beforehand.
**/
private Response doInvoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
request.setEndpoint(endpoint);
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory
.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler,
executionContext);
}
}