com.amazonaws.services.ebs.AmazonEBSAsync Maven / Gradle / Ivy
/*
* Copyright 2017-2022 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.ebs;
import javax.annotation.Generated;
import com.amazonaws.services.ebs.model.*;
/**
* Interface for accessing Amazon EBS asynchronously. Each asynchronous method will return a Java Future object
* representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
* notification when an asynchronous operation completes.
*
* Note: Do not directly implement this interface, new methods are added to it regularly. Extend from
* {@link com.amazonaws.services.ebs.AbstractAmazonEBSAsync} instead.
*
*
*
* You can use the Amazon Elastic Block Store (Amazon EBS) direct APIs to create Amazon EBS snapshots, write data
* directly to your snapshots, read data on your snapshots, and identify the differences or changes between two
* snapshots. If you’re an independent software vendor (ISV) who offers backup services for Amazon EBS, the EBS direct
* APIs make it more efficient and cost-effective to track incremental changes on your Amazon EBS volumes through
* snapshots. This can be done without having to create new volumes from snapshots, and then use Amazon Elastic Compute
* Cloud (Amazon EC2) instances to compare the differences.
*
*
* You can create incremental snapshots directly from data on-premises into volumes and the cloud to use for quick
* disaster recovery. With the ability to write and read snapshots, you can write your on-premises data to an snapshot
* during a disaster. Then after recovery, you can restore it back to Amazon Web Services or on-premises from the
* snapshot. You no longer need to build and maintain complex mechanisms to copy data to and from Amazon EBS.
*
*
* This API reference provides detailed information about the actions, data types, parameters, and errors of the EBS
* direct APIs. For more information about the elements that make up the EBS direct APIs, and examples of how to use
* them effectively, see Accessing the Contents of an
* Amazon EBS Snapshot in the Amazon Elastic Compute Cloud User Guide. For more information about the
* supported Amazon Web Services Regions, endpoints, and service quotas for the EBS direct APIs, see Amazon Elastic Block Store Endpoints and
* Quotas in the Amazon Web Services General Reference.
*
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public interface AmazonEBSAsync extends AmazonEBS {
/**
*
* Seals and completes the snapshot after all of the required blocks of data have been written to it. Completing the
* snapshot changes the status to completed. You cannot write new blocks to a snapshot after it has
* been completed.
*
*
* @param completeSnapshotRequest
* @return A Java Future containing the result of the CompleteSnapshot operation returned by the service.
* @sample AmazonEBSAsync.CompleteSnapshot
* @see AWS API
* Documentation
*/
java.util.concurrent.Future completeSnapshotAsync(CompleteSnapshotRequest completeSnapshotRequest);
/**
*
* Seals and completes the snapshot after all of the required blocks of data have been written to it. Completing the
* snapshot changes the status to completed. You cannot write new blocks to a snapshot after it has
* been completed.
*
*
* @param completeSnapshotRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CompleteSnapshot operation returned by the service.
* @sample AmazonEBSAsyncHandler.CompleteSnapshot
* @see AWS API
* Documentation
*/
java.util.concurrent.Future completeSnapshotAsync(CompleteSnapshotRequest completeSnapshotRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns the data in a block in an Amazon Elastic Block Store snapshot.
*
*
* @param getSnapshotBlockRequest
* @return A Java Future containing the result of the GetSnapshotBlock operation returned by the service.
* @sample AmazonEBSAsync.GetSnapshotBlock
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getSnapshotBlockAsync(GetSnapshotBlockRequest getSnapshotBlockRequest);
/**
*
* Returns the data in a block in an Amazon Elastic Block Store snapshot.
*
*
* @param getSnapshotBlockRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetSnapshotBlock operation returned by the service.
* @sample AmazonEBSAsyncHandler.GetSnapshotBlock
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getSnapshotBlockAsync(GetSnapshotBlockRequest getSnapshotBlockRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns information about the blocks that are different between two Amazon Elastic Block Store snapshots of the
* same volume/snapshot lineage.
*
*
* @param listChangedBlocksRequest
* @return A Java Future containing the result of the ListChangedBlocks operation returned by the service.
* @sample AmazonEBSAsync.ListChangedBlocks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listChangedBlocksAsync(ListChangedBlocksRequest listChangedBlocksRequest);
/**
*
* Returns information about the blocks that are different between two Amazon Elastic Block Store snapshots of the
* same volume/snapshot lineage.
*
*
* @param listChangedBlocksRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListChangedBlocks operation returned by the service.
* @sample AmazonEBSAsyncHandler.ListChangedBlocks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listChangedBlocksAsync(ListChangedBlocksRequest listChangedBlocksRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns information about the blocks in an Amazon Elastic Block Store snapshot.
*
*
* @param listSnapshotBlocksRequest
* @return A Java Future containing the result of the ListSnapshotBlocks operation returned by the service.
* @sample AmazonEBSAsync.ListSnapshotBlocks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listSnapshotBlocksAsync(ListSnapshotBlocksRequest listSnapshotBlocksRequest);
/**
*
* Returns information about the blocks in an Amazon Elastic Block Store snapshot.
*
*
* @param listSnapshotBlocksRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListSnapshotBlocks operation returned by the service.
* @sample AmazonEBSAsyncHandler.ListSnapshotBlocks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listSnapshotBlocksAsync(ListSnapshotBlocksRequest listSnapshotBlocksRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Writes a block of data to a snapshot. If the specified block contains data, the existing data is overwritten. The
* target snapshot must be in the pending state.
*
*
* Data written to a snapshot must be aligned with 512-KiB sectors.
*
*
* @param putSnapshotBlockRequest
* @return A Java Future containing the result of the PutSnapshotBlock operation returned by the service.
* @sample AmazonEBSAsync.PutSnapshotBlock
* @see AWS API
* Documentation
*/
java.util.concurrent.Future putSnapshotBlockAsync(PutSnapshotBlockRequest putSnapshotBlockRequest);
/**
*
* Writes a block of data to a snapshot. If the specified block contains data, the existing data is overwritten. The
* target snapshot must be in the pending state.
*
*
* Data written to a snapshot must be aligned with 512-KiB sectors.
*
*
* @param putSnapshotBlockRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutSnapshotBlock operation returned by the service.
* @sample AmazonEBSAsyncHandler.PutSnapshotBlock
* @see AWS API
* Documentation
*/
java.util.concurrent.Future putSnapshotBlockAsync(PutSnapshotBlockRequest putSnapshotBlockRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Creates a new Amazon EBS snapshot. The new snapshot enters the pending state after the request
* completes.
*
*
* After creating the snapshot, use PutSnapshotBlock to
* write blocks of data to the snapshot.
*
*
* @param startSnapshotRequest
* @return A Java Future containing the result of the StartSnapshot operation returned by the service.
* @sample AmazonEBSAsync.StartSnapshot
* @see AWS API
* Documentation
*/
java.util.concurrent.Future startSnapshotAsync(StartSnapshotRequest startSnapshotRequest);
/**
*
* Creates a new Amazon EBS snapshot. The new snapshot enters the pending state after the request
* completes.
*
*
* After creating the snapshot, use PutSnapshotBlock to
* write blocks of data to the snapshot.
*
*
* @param startSnapshotRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the StartSnapshot operation returned by the service.
* @sample AmazonEBSAsyncHandler.StartSnapshot
* @see AWS API
* Documentation
*/
java.util.concurrent.Future startSnapshotAsync(StartSnapshotRequest startSnapshotRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
}