com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceAsyncClient Maven / Gradle / Ivy
Show all versions of aws-android-sdk-ses Show documentation
/*
* Copyright 2010-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.simpleemail;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.handlers.AsyncHandler;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.simpleemail.model.*;
/**
* Asynchronous client for accessing AmazonSimpleEmailService.
* All asynchronous calls made using this client are non-blocking. Callers could either
* process the result and handle the exceptions in the worker thread by providing a callback handler
* when making the call, or use the returned Future object to check the result of the call in the calling thread.
* Amazon Simple Email Service
* This is the API Reference for Amazon Simple Email Service (Amazon
* SES). This documentation is intended to be used in conjunction with
* the
* Amazon SES Developer Guide
* .
*
*
* NOTE:For a list of Amazon SES endpoints to use in service
* requests, see Regions and Amazon SES in the Amazon SES Developer
* Guide.
*
*/
public class AmazonSimpleEmailServiceAsyncClient extends AmazonSimpleEmailServiceClient
implements AmazonSimpleEmailServiceAsync {
/**
* Executor service for executing asynchronous requests.
*/
private ExecutorService executorService;
private static final int DEFAULT_THREAD_POOL_SIZE = 10;
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService. A credentials provider chain will be used
* that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @see DefaultAWSCredentialsProviderChain
*/
@Deprecated
public AmazonSimpleEmailServiceAsyncClient() {
this(new DefaultAWSCredentialsProviderChain());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService. 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 AmazonSimpleEmailService
* (ex: proxy settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
*/
@Deprecated
public AmazonSimpleEmailServiceAsyncClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService using the specified AWS account credentials.
* Default client settings will be used, and a fixed size thread pool will be
* created for executing the asynchronous tasks.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentials The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
*/
public AmazonSimpleEmailServiceAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, Executors.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService using the specified AWS account credentials
* and executor service. Default client settings will be used.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will
* be executed.
*/
public AmazonSimpleEmailServiceAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {
super(awsCredentials);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService using the specified AWS account credentials,
* executor service, and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy
* settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will
* be executed.
*/
public AmazonSimpleEmailServiceAsyncClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService using the specified AWS account credentials provider.
* Default client settings will be used, and a fixed size thread pool will be
* created for executing the asynchronous tasks.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
*/
public AmazonSimpleEmailServiceAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, Executors.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService using the specified AWS account credentials provider
* and executor service. Default client settings will be used.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will
* be executed.
*/
public AmazonSimpleEmailServiceAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
this(awsCredentialsProvider, new ClientConfiguration(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService using the specified AWS account credentials
* provider and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy
* settings, etc).
*/
public AmazonSimpleEmailServiceAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonSimpleEmailService using the specified AWS account credentials
* provider, executor service, and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy
* settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will
* be executed.
*/
public AmazonSimpleEmailServiceAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Returns the executor service used by this async client to execute
* requests.
*
* @return The executor service used by this async client to execute
* requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
/**
* Shuts down the client, releasing all managed resources. This includes
* forcibly terminating all pending asynchronous service calls. Clients who
* wish to give pending asynchronous service calls time to complete should
* call getExecutorService().shutdown() followed by
* getExecutorService().awaitTermination() prior to calling this method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
/**
*
* Returns the user's current sending limits.
*
*
* This action is throttled at one request per second.
*
*
* @param getSendQuotaRequest Container for the necessary parameters to
* execute the GetSendQuota operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* GetSendQuota service method, as returned by AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getSendQuotaAsync(final GetSendQuotaRequest getSendQuotaRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetSendQuotaResult call() throws Exception {
return getSendQuota(getSendQuotaRequest);
}
});
}
/**
*
* Returns the user's current sending limits.
*
*
* This action is throttled at one request per second.
*
*
* @param getSendQuotaRequest Container for the necessary parameters to
* execute the GetSendQuota operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetSendQuota service method, as returned by AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getSendQuotaAsync(
final GetSendQuotaRequest getSendQuotaRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetSendQuotaResult call() throws Exception {
GetSendQuotaResult result;
try {
result = getSendQuota(getSendQuotaRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getSendQuotaRequest, result);
return result;
}
});
}
/**
*
* Sets the position of the specified receipt rule in the receipt rule
* set.
*
*
* For information about managing receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param setReceiptRulePositionRequest Container for the necessary
* parameters to execute the SetReceiptRulePosition operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SetReceiptRulePosition service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setReceiptRulePositionAsync(final SetReceiptRulePositionRequest setReceiptRulePositionRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetReceiptRulePositionResult call() throws Exception {
return setReceiptRulePosition(setReceiptRulePositionRequest);
}
});
}
/**
*
* Sets the position of the specified receipt rule in the receipt rule
* set.
*
*
* For information about managing receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param setReceiptRulePositionRequest Container for the necessary
* parameters to execute the SetReceiptRulePosition operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SetReceiptRulePosition service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setReceiptRulePositionAsync(
final SetReceiptRulePositionRequest setReceiptRulePositionRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetReceiptRulePositionResult call() throws Exception {
SetReceiptRulePositionResult result;
try {
result = setReceiptRulePosition(setReceiptRulePositionRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(setReceiptRulePositionRequest, result);
return result;
}
});
}
/**
*
* Deletes the specified identity (email address or domain) from the
* list of verified identities.
*
*
* This action is throttled at one request per second.
*
*
* @param deleteIdentityRequest Container for the necessary parameters to
* execute the DeleteIdentity operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DeleteIdentity service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteIdentityAsync(final DeleteIdentityRequest deleteIdentityRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteIdentityResult call() throws Exception {
return deleteIdentity(deleteIdentityRequest);
}
});
}
/**
*
* Deletes the specified identity (email address or domain) from the
* list of verified identities.
*
*
* This action is throttled at one request per second.
*
*
* @param deleteIdentityRequest Container for the necessary parameters to
* execute the DeleteIdentity operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteIdentity service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteIdentityAsync(
final DeleteIdentityRequest deleteIdentityRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteIdentityResult call() throws Exception {
DeleteIdentityResult result;
try {
result = deleteIdentity(deleteIdentityRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteIdentityRequest, result);
return result;
}
});
}
/**
*
* Enables or disables Easy DKIM signing of email sent from an identity:
*
*
*
* - If Easy DKIM signing is enabled for a domain name identity (e.g.,
*
example.com ), then Amazon SES will DKIM-sign all email
* sent by addresses under that domain name (e.g.,
* [email protected] ).
* - If Easy DKIM signing is enabled for an email address, then Amazon
* SES will DKIM-sign all email sent by that email address.
*
*
*
* For email addresses (e.g., [email protected] ), you can
* only enable Easy DKIM signing if the corresponding domain (e.g.,
* example.com ) has been set up for Easy DKIM using the AWS
* Console or the VerifyDomainDkim action.
*
*
* This action is throttled at one request per second.
*
*
* For more information about Easy DKIM signing, go to the
* Amazon SES Developer Guide
* .
*
*
* @param setIdentityDkimEnabledRequest Container for the necessary
* parameters to execute the SetIdentityDkimEnabled operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SetIdentityDkimEnabled service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setIdentityDkimEnabledAsync(final SetIdentityDkimEnabledRequest setIdentityDkimEnabledRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetIdentityDkimEnabledResult call() throws Exception {
return setIdentityDkimEnabled(setIdentityDkimEnabledRequest);
}
});
}
/**
*
* Enables or disables Easy DKIM signing of email sent from an identity:
*
*
*
* - If Easy DKIM signing is enabled for a domain name identity (e.g.,
*
example.com ), then Amazon SES will DKIM-sign all email
* sent by addresses under that domain name (e.g.,
* [email protected] ).
* - If Easy DKIM signing is enabled for an email address, then Amazon
* SES will DKIM-sign all email sent by that email address.
*
*
*
* For email addresses (e.g., [email protected] ), you can
* only enable Easy DKIM signing if the corresponding domain (e.g.,
* example.com ) has been set up for Easy DKIM using the AWS
* Console or the VerifyDomainDkim action.
*
*
* This action is throttled at one request per second.
*
*
* For more information about Easy DKIM signing, go to the
* Amazon SES Developer Guide
* .
*
*
* @param setIdentityDkimEnabledRequest Container for the necessary
* parameters to execute the SetIdentityDkimEnabled operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SetIdentityDkimEnabled service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setIdentityDkimEnabledAsync(
final SetIdentityDkimEnabledRequest setIdentityDkimEnabledRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetIdentityDkimEnabledResult call() throws Exception {
SetIdentityDkimEnabledResult result;
try {
result = setIdentityDkimEnabled(setIdentityDkimEnabledRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(setIdentityDkimEnabledRequest, result);
return result;
}
});
}
/**
*
* Creates a receipt rule set by cloning an existing one. All receipt
* rules and configurations are copied to the new receipt rule set and
* are completely independent of the source rule set.
*
*
* For information about setting up rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param cloneReceiptRuleSetRequest Container for the necessary
* parameters to execute the CloneReceiptRuleSet operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* CloneReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future cloneReceiptRuleSetAsync(final CloneReceiptRuleSetRequest cloneReceiptRuleSetRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CloneReceiptRuleSetResult call() throws Exception {
return cloneReceiptRuleSet(cloneReceiptRuleSetRequest);
}
});
}
/**
*
* Creates a receipt rule set by cloning an existing one. All receipt
* rules and configurations are copied to the new receipt rule set and
* are completely independent of the source rule set.
*
*
* For information about setting up rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param cloneReceiptRuleSetRequest Container for the necessary
* parameters to execute the CloneReceiptRuleSet operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CloneReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future cloneReceiptRuleSetAsync(
final CloneReceiptRuleSetRequest cloneReceiptRuleSetRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CloneReceiptRuleSetResult call() throws Exception {
CloneReceiptRuleSetResult result;
try {
result = cloneReceiptRuleSet(cloneReceiptRuleSetRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(cloneReceiptRuleSetRequest, result);
return result;
}
});
}
/**
*
* Returns the current status of Easy DKIM signing for an entity. For
* domain name identities, this action also returns the DKIM tokens that
* are required for Easy DKIM signing, and whether Amazon SES has
* successfully verified that these tokens have been published.
*
*
* This action takes a list of identities as input and returns the
* following information for each:
*
*
*
* - Whether Easy DKIM signing is enabled or disabled.
* - A set of DKIM tokens that represent the identity. If the identity
* is an email address, the tokens represent the domain of that
* address.
* - Whether Amazon SES has successfully verified the DKIM tokens
* published in the domain's DNS. This information is only returned for
* domain name identities, not for email addresses.
*
*
*
* This action is throttled at one request per second and can only get
* DKIM attributes for up to 100 identities at a time.
*
*
* For more information about creating DNS records using DKIM tokens, go
* to the
* Amazon SES Developer Guide
* .
*
*
* @param getIdentityDkimAttributesRequest Container for the necessary
* parameters to execute the GetIdentityDkimAttributes operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* GetIdentityDkimAttributes service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityDkimAttributesAsync(final GetIdentityDkimAttributesRequest getIdentityDkimAttributesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityDkimAttributesResult call() throws Exception {
return getIdentityDkimAttributes(getIdentityDkimAttributesRequest);
}
});
}
/**
*
* Returns the current status of Easy DKIM signing for an entity. For
* domain name identities, this action also returns the DKIM tokens that
* are required for Easy DKIM signing, and whether Amazon SES has
* successfully verified that these tokens have been published.
*
*
* This action takes a list of identities as input and returns the
* following information for each:
*
*
*
* - Whether Easy DKIM signing is enabled or disabled.
* - A set of DKIM tokens that represent the identity. If the identity
* is an email address, the tokens represent the domain of that
* address.
* - Whether Amazon SES has successfully verified the DKIM tokens
* published in the domain's DNS. This information is only returned for
* domain name identities, not for email addresses.
*
*
*
* This action is throttled at one request per second and can only get
* DKIM attributes for up to 100 identities at a time.
*
*
* For more information about creating DNS records using DKIM tokens, go
* to the
* Amazon SES Developer Guide
* .
*
*
* @param getIdentityDkimAttributesRequest Container for the necessary
* parameters to execute the GetIdentityDkimAttributes operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetIdentityDkimAttributes service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityDkimAttributesAsync(
final GetIdentityDkimAttributesRequest getIdentityDkimAttributesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityDkimAttributesResult call() throws Exception {
GetIdentityDkimAttributesResult result;
try {
result = getIdentityDkimAttributes(getIdentityDkimAttributesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getIdentityDkimAttributesRequest, result);
return result;
}
});
}
/**
*
* Returns the requested sending authorization policies for the given
* identity (email address or domain). The policies are returned as a map
* of policy names to policy contents. You can retrieve a maximum of 20
* policies at a time.
*
*
* NOTE:This API is for the identity owner only. If you have not
* verified the identity, this API will return an error.
*
*
* Sending authorization is a feature that enables an identity owner to
* authorize other senders to use its identities. For information about
* using sending authorization, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param getIdentityPoliciesRequest Container for the necessary
* parameters to execute the GetIdentityPolicies operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* GetIdentityPolicies service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityPoliciesAsync(final GetIdentityPoliciesRequest getIdentityPoliciesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityPoliciesResult call() throws Exception {
return getIdentityPolicies(getIdentityPoliciesRequest);
}
});
}
/**
*
* Returns the requested sending authorization policies for the given
* identity (email address or domain). The policies are returned as a map
* of policy names to policy contents. You can retrieve a maximum of 20
* policies at a time.
*
*
* NOTE:This API is for the identity owner only. If you have not
* verified the identity, this API will return an error.
*
*
* Sending authorization is a feature that enables an identity owner to
* authorize other senders to use its identities. For information about
* using sending authorization, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param getIdentityPoliciesRequest Container for the necessary
* parameters to execute the GetIdentityPolicies operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetIdentityPolicies service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityPoliciesAsync(
final GetIdentityPoliciesRequest getIdentityPoliciesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityPoliciesResult call() throws Exception {
GetIdentityPoliciesResult result;
try {
result = getIdentityPolicies(getIdentityPoliciesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getIdentityPoliciesRequest, result);
return result;
}
});
}
/**
*
* Returns a list of sending authorization policies that are attached to
* the given identity (email address or domain). This API returns only a
* list. If you want the actual policy content, you can use
* GetIdentityPolicies .
*
*
* NOTE:This API is for the identity owner only. If you have not
* verified the identity, this API will return an error.
*
*
* Sending authorization is a feature that enables an identity owner to
* authorize other senders to use its identities. For information about
* using sending authorization, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param listIdentityPoliciesRequest Container for the necessary
* parameters to execute the ListIdentityPolicies operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* ListIdentityPolicies service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listIdentityPoliciesAsync(final ListIdentityPoliciesRequest listIdentityPoliciesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListIdentityPoliciesResult call() throws Exception {
return listIdentityPolicies(listIdentityPoliciesRequest);
}
});
}
/**
*
* Returns a list of sending authorization policies that are attached to
* the given identity (email address or domain). This API returns only a
* list. If you want the actual policy content, you can use
* GetIdentityPolicies .
*
*
* NOTE:This API is for the identity owner only. If you have not
* verified the identity, this API will return an error.
*
*
* Sending authorization is a feature that enables an identity owner to
* authorize other senders to use its identities. For information about
* using sending authorization, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param listIdentityPoliciesRequest Container for the necessary
* parameters to execute the ListIdentityPolicies operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListIdentityPolicies service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listIdentityPoliciesAsync(
final ListIdentityPoliciesRequest listIdentityPoliciesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListIdentityPoliciesResult call() throws Exception {
ListIdentityPoliciesResult result;
try {
result = listIdentityPolicies(listIdentityPoliciesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listIdentityPoliciesRequest, result);
return result;
}
});
}
/**
*
* Returns the custom MAIL FROM attributes for a list of identities
* (email addresses and/or domains).
*
*
* This action is throttled at one request per second and can only get
* custom MAIL FROM attributes for up to 100 identities at a time.
*
*
* @param getIdentityMailFromDomainAttributesRequest Container for the
* necessary parameters to execute the
* GetIdentityMailFromDomainAttributes operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* GetIdentityMailFromDomainAttributes service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityMailFromDomainAttributesAsync(final GetIdentityMailFromDomainAttributesRequest getIdentityMailFromDomainAttributesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityMailFromDomainAttributesResult call() throws Exception {
return getIdentityMailFromDomainAttributes(getIdentityMailFromDomainAttributesRequest);
}
});
}
/**
*
* Returns the custom MAIL FROM attributes for a list of identities
* (email addresses and/or domains).
*
*
* This action is throttled at one request per second and can only get
* custom MAIL FROM attributes for up to 100 identities at a time.
*
*
* @param getIdentityMailFromDomainAttributesRequest Container for the
* necessary parameters to execute the
* GetIdentityMailFromDomainAttributes operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetIdentityMailFromDomainAttributes service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityMailFromDomainAttributesAsync(
final GetIdentityMailFromDomainAttributesRequest getIdentityMailFromDomainAttributesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityMailFromDomainAttributesResult call() throws Exception {
GetIdentityMailFromDomainAttributesResult result;
try {
result = getIdentityMailFromDomainAttributes(getIdentityMailFromDomainAttributesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getIdentityMailFromDomainAttributesRequest, result);
return result;
}
});
}
/**
*
* Lists the receipt rule sets that exist under your AWS account. If
* there are additional receipt rule sets to be retrieved, you will
* receive a NextToken that you can provide to the next call
* to ListReceiptRuleSets to retrieve the additional
* entries.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param listReceiptRuleSetsRequest Container for the necessary
* parameters to execute the ListReceiptRuleSets operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* ListReceiptRuleSets service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listReceiptRuleSetsAsync(final ListReceiptRuleSetsRequest listReceiptRuleSetsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListReceiptRuleSetsResult call() throws Exception {
return listReceiptRuleSets(listReceiptRuleSetsRequest);
}
});
}
/**
*
* Lists the receipt rule sets that exist under your AWS account. If
* there are additional receipt rule sets to be retrieved, you will
* receive a NextToken that you can provide to the next call
* to ListReceiptRuleSets to retrieve the additional
* entries.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param listReceiptRuleSetsRequest Container for the necessary
* parameters to execute the ListReceiptRuleSets operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListReceiptRuleSets service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listReceiptRuleSetsAsync(
final ListReceiptRuleSetsRequest listReceiptRuleSetsRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListReceiptRuleSetsResult call() throws Exception {
ListReceiptRuleSetsResult result;
try {
result = listReceiptRuleSets(listReceiptRuleSetsRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listReceiptRuleSetsRequest, result);
return result;
}
});
}
/**
*
* Lists the IP address filters associated with your account.
*
*
* For information about managing IP address filters, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param listReceiptFiltersRequest Container for the necessary
* parameters to execute the ListReceiptFilters operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* ListReceiptFilters service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listReceiptFiltersAsync(final ListReceiptFiltersRequest listReceiptFiltersRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListReceiptFiltersResult call() throws Exception {
return listReceiptFilters(listReceiptFiltersRequest);
}
});
}
/**
*
* Lists the IP address filters associated with your account.
*
*
* For information about managing IP address filters, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param listReceiptFiltersRequest Container for the necessary
* parameters to execute the ListReceiptFilters operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListReceiptFilters service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listReceiptFiltersAsync(
final ListReceiptFiltersRequest listReceiptFiltersRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListReceiptFiltersResult call() throws Exception {
ListReceiptFiltersResult result;
try {
result = listReceiptFilters(listReceiptFiltersRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listReceiptFiltersRequest, result);
return result;
}
});
}
/**
*
* Creates a new IP address filter.
*
*
* For information about setting up IP address filters, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param createReceiptFilterRequest Container for the necessary
* parameters to execute the CreateReceiptFilter operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* CreateReceiptFilter service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createReceiptFilterAsync(final CreateReceiptFilterRequest createReceiptFilterRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateReceiptFilterResult call() throws Exception {
return createReceiptFilter(createReceiptFilterRequest);
}
});
}
/**
*
* Creates a new IP address filter.
*
*
* For information about setting up IP address filters, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param createReceiptFilterRequest Container for the necessary
* parameters to execute the CreateReceiptFilter operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateReceiptFilter service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createReceiptFilterAsync(
final CreateReceiptFilterRequest createReceiptFilterRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateReceiptFilterResult call() throws Exception {
CreateReceiptFilterResult result;
try {
result = createReceiptFilter(createReceiptFilterRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createReceiptFilterRequest, result);
return result;
}
});
}
/**
*
* Deletes the specified email address from the list of verified
* addresses.
*
*
* IMPORTANT:The DeleteVerifiedEmailAddress action is deprecated
* as of the May 15, 2012 release of Domain Verification. The
* DeleteIdentity action is now preferred.
*
*
* This action is throttled at one request per second.
*
*
* @param deleteVerifiedEmailAddressRequest Container for the necessary
* parameters to execute the DeleteVerifiedEmailAddress operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DeleteVerifiedEmailAddress service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteVerifiedEmailAddressAsync(final DeleteVerifiedEmailAddressRequest deleteVerifiedEmailAddressRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public Void call() throws Exception {
deleteVerifiedEmailAddress(deleteVerifiedEmailAddressRequest);
return null;
}
});
}
/**
*
* Deletes the specified email address from the list of verified
* addresses.
*
*
* IMPORTANT:The DeleteVerifiedEmailAddress action is deprecated
* as of the May 15, 2012 release of Domain Verification. The
* DeleteIdentity action is now preferred.
*
*
* This action is throttled at one request per second.
*
*
* @param deleteVerifiedEmailAddressRequest Container for the necessary
* parameters to execute the DeleteVerifiedEmailAddress operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteVerifiedEmailAddress service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteVerifiedEmailAddressAsync(
final DeleteVerifiedEmailAddressRequest deleteVerifiedEmailAddressRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public Void call() throws Exception {
try {
deleteVerifiedEmailAddress(deleteVerifiedEmailAddressRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteVerifiedEmailAddressRequest, null);
return null;
}
});
}
/**
*
* Verifies a domain.
*
*
* This action is throttled at one request per second.
*
*
* @param verifyDomainIdentityRequest Container for the necessary
* parameters to execute the VerifyDomainIdentity operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* VerifyDomainIdentity service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future verifyDomainIdentityAsync(final VerifyDomainIdentityRequest verifyDomainIdentityRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public VerifyDomainIdentityResult call() throws Exception {
return verifyDomainIdentity(verifyDomainIdentityRequest);
}
});
}
/**
*
* Verifies a domain.
*
*
* This action is throttled at one request per second.
*
*
* @param verifyDomainIdentityRequest Container for the necessary
* parameters to execute the VerifyDomainIdentity operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* VerifyDomainIdentity service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future verifyDomainIdentityAsync(
final VerifyDomainIdentityRequest verifyDomainIdentityRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public VerifyDomainIdentityResult call() throws Exception {
VerifyDomainIdentityResult result;
try {
result = verifyDomainIdentity(verifyDomainIdentityRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(verifyDomainIdentityRequest, result);
return result;
}
});
}
/**
*
* Enables or disables the custom MAIL FROM domain setup for a verified
* identity (email address or domain).
*
*
* IMPORTANT:To send emails using the specified MAIL FROM domain,
* you must add an MX record to your MAIL FROM domain's DNS settings. If
* you want your emails to pass Sender Policy Framework (SPF) checks, you
* must also add or update an SPF record. For more information, see the
* Amazon SES Developer Guide.
*
*
* This action is throttled at one request per second.
*
*
* @param setIdentityMailFromDomainRequest Container for the necessary
* parameters to execute the SetIdentityMailFromDomain operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SetIdentityMailFromDomain service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setIdentityMailFromDomainAsync(final SetIdentityMailFromDomainRequest setIdentityMailFromDomainRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetIdentityMailFromDomainResult call() throws Exception {
return setIdentityMailFromDomain(setIdentityMailFromDomainRequest);
}
});
}
/**
*
* Enables or disables the custom MAIL FROM domain setup for a verified
* identity (email address or domain).
*
*
* IMPORTANT:To send emails using the specified MAIL FROM domain,
* you must add an MX record to your MAIL FROM domain's DNS settings. If
* you want your emails to pass Sender Policy Framework (SPF) checks, you
* must also add or update an SPF record. For more information, see the
* Amazon SES Developer Guide.
*
*
* This action is throttled at one request per second.
*
*
* @param setIdentityMailFromDomainRequest Container for the necessary
* parameters to execute the SetIdentityMailFromDomain operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SetIdentityMailFromDomain service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setIdentityMailFromDomainAsync(
final SetIdentityMailFromDomainRequest setIdentityMailFromDomainRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetIdentityMailFromDomainResult call() throws Exception {
SetIdentityMailFromDomainResult result;
try {
result = setIdentityMailFromDomain(setIdentityMailFromDomainRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(setIdentityMailFromDomainRequest, result);
return result;
}
});
}
/**
*
* Reorders the receipt rules within a receipt rule set.
*
*
* NOTE:All of the rules in the rule set must be represented in
* this request. That is, this API will return an error if the reorder
* request doesn't explicitly position all of the rules.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param reorderReceiptRuleSetRequest Container for the necessary
* parameters to execute the ReorderReceiptRuleSet operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* ReorderReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future reorderReceiptRuleSetAsync(final ReorderReceiptRuleSetRequest reorderReceiptRuleSetRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ReorderReceiptRuleSetResult call() throws Exception {
return reorderReceiptRuleSet(reorderReceiptRuleSetRequest);
}
});
}
/**
*
* Reorders the receipt rules within a receipt rule set.
*
*
* NOTE:All of the rules in the rule set must be represented in
* this request. That is, this API will return an error if the reorder
* request doesn't explicitly position all of the rules.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param reorderReceiptRuleSetRequest Container for the necessary
* parameters to execute the ReorderReceiptRuleSet operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ReorderReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future reorderReceiptRuleSetAsync(
final ReorderReceiptRuleSetRequest reorderReceiptRuleSetRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ReorderReceiptRuleSetResult call() throws Exception {
ReorderReceiptRuleSetResult result;
try {
result = reorderReceiptRuleSet(reorderReceiptRuleSetRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(reorderReceiptRuleSetRequest, result);
return result;
}
});
}
/**
*
* Updates a receipt rule.
*
*
* For information about managing receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param updateReceiptRuleRequest Container for the necessary parameters
* to execute the UpdateReceiptRule operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* UpdateReceiptRule service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future updateReceiptRuleAsync(final UpdateReceiptRuleRequest updateReceiptRuleRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public UpdateReceiptRuleResult call() throws Exception {
return updateReceiptRule(updateReceiptRuleRequest);
}
});
}
/**
*
* Updates a receipt rule.
*
*
* For information about managing receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param updateReceiptRuleRequest Container for the necessary parameters
* to execute the UpdateReceiptRule operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateReceiptRule service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future updateReceiptRuleAsync(
final UpdateReceiptRuleRequest updateReceiptRuleRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public UpdateReceiptRuleResult call() throws Exception {
UpdateReceiptRuleResult result;
try {
result = updateReceiptRule(updateReceiptRuleRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateReceiptRuleRequest, result);
return result;
}
});
}
/**
*
* Sends an email message, with header and content specified by the
* client. The SendRawEmail action is useful for sending
* multipart MIME emails. The raw text of the message must comply with
* Internet email standards; otherwise, the message cannot be sent.
*
*
* There are several important points to know about
* SendRawEmail :
*
*
*
* - You can only send email from verified email addresses and
* domains; otherwise, you will get an "Email address not verified"
* error. If your account is still in the Amazon SES sandbox, you must
* also verify every recipient email address except for the recipients
* provided by the Amazon SES mailbox simulator. For more information, go
* to the
* Amazon SES Developer Guide
* .
* - The total size of the message cannot exceed 10 MB. This includes
* any attachments that are part of the message.
* - Amazon SES has a limit on the total number of recipients per
* message. The combined number of To:, CC: and BCC: email addresses
* cannot exceed 50. If you need to send an email message to a larger
* audience, you can divide your recipient list into groups of 50 or
* fewer, and then call Amazon SES repeatedly to send the message to each
* group.
* - The To:, CC:, and BCC: headers in the raw message can contain a
* group list. Note that each recipient in a group list counts towards
* the 50-recipient limit.
* - For every message that you send, the total number of recipients
* (To:, CC: and BCC:) is counted against your sending quota - the
* maximum number of emails you can send in a 24-hour period. For
* information about your sending quota, go to the
* Amazon SES Developer Guide
* .
* - If you are using sending authorization to send on behalf of
* another user,
SendRawEmail enables you to specify the
* cross-account identity for the email's "Source," "From," and
* "Return-Path" parameters in one of two ways: you can pass optional
* parameters SourceArn , FromArn , and/or
* ReturnPathArn to the API, or you can include the
* following X-headers in the header of your raw email:
*
* -
X-SES-SOURCE-ARN
* -
X-SES-FROM-ARN
* -
X-SES-RETURN-PATH-ARN
*
*
*
* IMPORTANT:Do not include these X-headers in the DKIM
* signature, because they are removed by Amazon SES before sending the
* email.
*
* For the most common sending authorization use case, we recommend that
* you specify the SourceIdentityArn and do not specify
* either the FromIdentityArn or
* ReturnPathIdentityArn . (The same note applies to the
* corresponding X-headers.) If you only specify the
* SourceIdentityArn , Amazon SES will simply set the "From"
* address and the "Return Path" address to the identity specified in
* SourceIdentityArn . For more information about sending
* authorization, see the
* Amazon SES Developer Guide
* .
*
*
*
* @param sendRawEmailRequest Container for the necessary parameters to
* execute the SendRawEmail operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SendRawEmail service method, as returned by AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future sendRawEmailAsync(final SendRawEmailRequest sendRawEmailRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SendRawEmailResult call() throws Exception {
return sendRawEmail(sendRawEmailRequest);
}
});
}
/**
*
* Sends an email message, with header and content specified by the
* client. The SendRawEmail action is useful for sending
* multipart MIME emails. The raw text of the message must comply with
* Internet email standards; otherwise, the message cannot be sent.
*
*
* There are several important points to know about
* SendRawEmail :
*
*
*
* - You can only send email from verified email addresses and
* domains; otherwise, you will get an "Email address not verified"
* error. If your account is still in the Amazon SES sandbox, you must
* also verify every recipient email address except for the recipients
* provided by the Amazon SES mailbox simulator. For more information, go
* to the
* Amazon SES Developer Guide
* .
* - The total size of the message cannot exceed 10 MB. This includes
* any attachments that are part of the message.
* - Amazon SES has a limit on the total number of recipients per
* message. The combined number of To:, CC: and BCC: email addresses
* cannot exceed 50. If you need to send an email message to a larger
* audience, you can divide your recipient list into groups of 50 or
* fewer, and then call Amazon SES repeatedly to send the message to each
* group.
* - The To:, CC:, and BCC: headers in the raw message can contain a
* group list. Note that each recipient in a group list counts towards
* the 50-recipient limit.
* - For every message that you send, the total number of recipients
* (To:, CC: and BCC:) is counted against your sending quota - the
* maximum number of emails you can send in a 24-hour period. For
* information about your sending quota, go to the
* Amazon SES Developer Guide
* .
* - If you are using sending authorization to send on behalf of
* another user,
SendRawEmail enables you to specify the
* cross-account identity for the email's "Source," "From," and
* "Return-Path" parameters in one of two ways: you can pass optional
* parameters SourceArn , FromArn , and/or
* ReturnPathArn to the API, or you can include the
* following X-headers in the header of your raw email:
*
* -
X-SES-SOURCE-ARN
* -
X-SES-FROM-ARN
* -
X-SES-RETURN-PATH-ARN
*
*
*
* IMPORTANT:Do not include these X-headers in the DKIM
* signature, because they are removed by Amazon SES before sending the
* email.
*
* For the most common sending authorization use case, we recommend that
* you specify the SourceIdentityArn and do not specify
* either the FromIdentityArn or
* ReturnPathIdentityArn . (The same note applies to the
* corresponding X-headers.) If you only specify the
* SourceIdentityArn , Amazon SES will simply set the "From"
* address and the "Return Path" address to the identity specified in
* SourceIdentityArn . For more information about sending
* authorization, see the
* Amazon SES Developer Guide
* .
*
*
*
* @param sendRawEmailRequest Container for the necessary parameters to
* execute the SendRawEmail operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SendRawEmail service method, as returned by AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future sendRawEmailAsync(
final SendRawEmailRequest sendRawEmailRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SendRawEmailResult call() throws Exception {
SendRawEmailResult result;
try {
result = sendRawEmail(sendRawEmailRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(sendRawEmailRequest, result);
return result;
}
});
}
/**
*
* Given a list of identities (email addresses and/or domains), returns
* the verification status and (for domain identities) the verification
* token for each identity.
*
*
* This action is throttled at one request per second and can only get
* verification attributes for up to 100 identities at a time.
*
*
* @param getIdentityVerificationAttributesRequest Container for the
* necessary parameters to execute the GetIdentityVerificationAttributes
* operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* GetIdentityVerificationAttributes service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityVerificationAttributesAsync(final GetIdentityVerificationAttributesRequest getIdentityVerificationAttributesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityVerificationAttributesResult call() throws Exception {
return getIdentityVerificationAttributes(getIdentityVerificationAttributesRequest);
}
});
}
/**
*
* Given a list of identities (email addresses and/or domains), returns
* the verification status and (for domain identities) the verification
* token for each identity.
*
*
* This action is throttled at one request per second and can only get
* verification attributes for up to 100 identities at a time.
*
*
* @param getIdentityVerificationAttributesRequest Container for the
* necessary parameters to execute the GetIdentityVerificationAttributes
* operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetIdentityVerificationAttributes service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityVerificationAttributesAsync(
final GetIdentityVerificationAttributesRequest getIdentityVerificationAttributesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityVerificationAttributesResult call() throws Exception {
GetIdentityVerificationAttributesResult result;
try {
result = getIdentityVerificationAttributes(getIdentityVerificationAttributesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getIdentityVerificationAttributesRequest, result);
return result;
}
});
}
/**
*
* Deletes the specified receipt rule.
*
*
* For information about managing receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param deleteReceiptRuleRequest Container for the necessary parameters
* to execute the DeleteReceiptRule operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DeleteReceiptRule service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteReceiptRuleAsync(final DeleteReceiptRuleRequest deleteReceiptRuleRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteReceiptRuleResult call() throws Exception {
return deleteReceiptRule(deleteReceiptRuleRequest);
}
});
}
/**
*
* Deletes the specified receipt rule.
*
*
* For information about managing receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param deleteReceiptRuleRequest Container for the necessary parameters
* to execute the DeleteReceiptRule operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteReceiptRule service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteReceiptRuleAsync(
final DeleteReceiptRuleRequest deleteReceiptRuleRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteReceiptRuleResult call() throws Exception {
DeleteReceiptRuleResult result;
try {
result = deleteReceiptRule(deleteReceiptRuleRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteReceiptRuleRequest, result);
return result;
}
});
}
/**
*
* Deletes the specified receipt rule set and all of the receipt rules
* it contains.
*
*
* NOTE:The currently active rule set cannot be deleted.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param deleteReceiptRuleSetRequest Container for the necessary
* parameters to execute the DeleteReceiptRuleSet operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DeleteReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteReceiptRuleSetAsync(final DeleteReceiptRuleSetRequest deleteReceiptRuleSetRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteReceiptRuleSetResult call() throws Exception {
return deleteReceiptRuleSet(deleteReceiptRuleSetRequest);
}
});
}
/**
*
* Deletes the specified receipt rule set and all of the receipt rules
* it contains.
*
*
* NOTE:The currently active rule set cannot be deleted.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param deleteReceiptRuleSetRequest Container for the necessary
* parameters to execute the DeleteReceiptRuleSet operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteReceiptRuleSetAsync(
final DeleteReceiptRuleSetRequest deleteReceiptRuleSetRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteReceiptRuleSetResult call() throws Exception {
DeleteReceiptRuleSetResult result;
try {
result = deleteReceiptRuleSet(deleteReceiptRuleSetRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteReceiptRuleSetRequest, result);
return result;
}
});
}
/**
*
* Given an identity (email address or domain), sets the Amazon Simple
* Notification Service (Amazon SNS) topic to which Amazon SES will
* publish bounce, complaint, and/or delivery notifications for emails
* sent with that identity as the Source .
*
*
* NOTE:Unless feedback forwarding is enabled, you must specify
* Amazon SNS topics for bounce and complaint notifications. For more
* information, see SetIdentityFeedbackForwardingEnabled.
*
*
* This action is throttled at one request per second.
*
*
* For more information about feedback notification, see the
* Amazon SES Developer Guide
* .
*
*
* @param setIdentityNotificationTopicRequest Container for the necessary
* parameters to execute the SetIdentityNotificationTopic operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SetIdentityNotificationTopic service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setIdentityNotificationTopicAsync(final SetIdentityNotificationTopicRequest setIdentityNotificationTopicRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetIdentityNotificationTopicResult call() throws Exception {
return setIdentityNotificationTopic(setIdentityNotificationTopicRequest);
}
});
}
/**
*
* Given an identity (email address or domain), sets the Amazon Simple
* Notification Service (Amazon SNS) topic to which Amazon SES will
* publish bounce, complaint, and/or delivery notifications for emails
* sent with that identity as the Source .
*
*
* NOTE:Unless feedback forwarding is enabled, you must specify
* Amazon SNS topics for bounce and complaint notifications. For more
* information, see SetIdentityFeedbackForwardingEnabled.
*
*
* This action is throttled at one request per second.
*
*
* For more information about feedback notification, see the
* Amazon SES Developer Guide
* .
*
*
* @param setIdentityNotificationTopicRequest Container for the necessary
* parameters to execute the SetIdentityNotificationTopic operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SetIdentityNotificationTopic service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setIdentityNotificationTopicAsync(
final SetIdentityNotificationTopicRequest setIdentityNotificationTopicRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetIdentityNotificationTopicResult call() throws Exception {
SetIdentityNotificationTopicResult result;
try {
result = setIdentityNotificationTopic(setIdentityNotificationTopicRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(setIdentityNotificationTopicRequest, result);
return result;
}
});
}
/**
*
* Creates a receipt rule.
*
*
* For information about setting up receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param createReceiptRuleRequest Container for the necessary parameters
* to execute the CreateReceiptRule operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* CreateReceiptRule service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createReceiptRuleAsync(final CreateReceiptRuleRequest createReceiptRuleRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateReceiptRuleResult call() throws Exception {
return createReceiptRule(createReceiptRuleRequest);
}
});
}
/**
*
* Creates a receipt rule.
*
*
* For information about setting up receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param createReceiptRuleRequest Container for the necessary parameters
* to execute the CreateReceiptRule operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateReceiptRule service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createReceiptRuleAsync(
final CreateReceiptRuleRequest createReceiptRuleRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateReceiptRuleResult call() throws Exception {
CreateReceiptRuleResult result;
try {
result = createReceiptRule(createReceiptRuleRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createReceiptRuleRequest, result);
return result;
}
});
}
/**
*
* Sets the specified receipt rule set as the active receipt rule set.
*
*
* NOTE:To disable your email-receiving through Amazon SES
* completely, you can call this API with RuleSetName set to null.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param setActiveReceiptRuleSetRequest Container for the necessary
* parameters to execute the SetActiveReceiptRuleSet operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SetActiveReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setActiveReceiptRuleSetAsync(final SetActiveReceiptRuleSetRequest setActiveReceiptRuleSetRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetActiveReceiptRuleSetResult call() throws Exception {
return setActiveReceiptRuleSet(setActiveReceiptRuleSetRequest);
}
});
}
/**
*
* Sets the specified receipt rule set as the active receipt rule set.
*
*
* NOTE:To disable your email-receiving through Amazon SES
* completely, you can call this API with RuleSetName set to null.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param setActiveReceiptRuleSetRequest Container for the necessary
* parameters to execute the SetActiveReceiptRuleSet operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SetActiveReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setActiveReceiptRuleSetAsync(
final SetActiveReceiptRuleSetRequest setActiveReceiptRuleSetRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetActiveReceiptRuleSetResult call() throws Exception {
SetActiveReceiptRuleSetResult result;
try {
result = setActiveReceiptRuleSet(setActiveReceiptRuleSetRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(setActiveReceiptRuleSetRequest, result);
return result;
}
});
}
/**
*
* Deletes the specified IP address filter.
*
*
* For information about managing IP address filters, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param deleteReceiptFilterRequest Container for the necessary
* parameters to execute the DeleteReceiptFilter operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DeleteReceiptFilter service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteReceiptFilterAsync(final DeleteReceiptFilterRequest deleteReceiptFilterRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteReceiptFilterResult call() throws Exception {
return deleteReceiptFilter(deleteReceiptFilterRequest);
}
});
}
/**
*
* Deletes the specified IP address filter.
*
*
* For information about managing IP address filters, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param deleteReceiptFilterRequest Container for the necessary
* parameters to execute the DeleteReceiptFilter operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteReceiptFilter service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteReceiptFilterAsync(
final DeleteReceiptFilterRequest deleteReceiptFilterRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteReceiptFilterResult call() throws Exception {
DeleteReceiptFilterResult result;
try {
result = deleteReceiptFilter(deleteReceiptFilterRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteReceiptFilterRequest, result);
return result;
}
});
}
/**
*
* Returns the details of the specified receipt rule set.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param describeReceiptRuleSetRequest Container for the necessary
* parameters to execute the DescribeReceiptRuleSet operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DescribeReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeReceiptRuleSetAsync(final DescribeReceiptRuleSetRequest describeReceiptRuleSetRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeReceiptRuleSetResult call() throws Exception {
return describeReceiptRuleSet(describeReceiptRuleSetRequest);
}
});
}
/**
*
* Returns the details of the specified receipt rule set.
*
*
* For information about managing receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param describeReceiptRuleSetRequest Container for the necessary
* parameters to execute the DescribeReceiptRuleSet operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DescribeReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeReceiptRuleSetAsync(
final DescribeReceiptRuleSetRequest describeReceiptRuleSetRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeReceiptRuleSetResult call() throws Exception {
DescribeReceiptRuleSetResult result;
try {
result = describeReceiptRuleSet(describeReceiptRuleSetRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(describeReceiptRuleSetRequest, result);
return result;
}
});
}
/**
*
* Given an identity (email address or domain), enables or disables
* whether Amazon SES forwards bounce and complaint notifications as
* email. Feedback forwarding can only be disabled when Amazon Simple
* Notification Service (Amazon SNS) topics are specified for both
* bounces and complaints.
*
*
* NOTE:Feedback forwarding does not apply to delivery
* notifications. Delivery notifications are only available through
* Amazon SNS.
*
*
* This action is throttled at one request per second.
*
*
* For more information about using notifications with Amazon SES, see
* the
* Amazon SES Developer Guide
* .
*
*
* @param setIdentityFeedbackForwardingEnabledRequest Container for the
* necessary parameters to execute the
* SetIdentityFeedbackForwardingEnabled operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SetIdentityFeedbackForwardingEnabled service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setIdentityFeedbackForwardingEnabledAsync(final SetIdentityFeedbackForwardingEnabledRequest setIdentityFeedbackForwardingEnabledRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetIdentityFeedbackForwardingEnabledResult call() throws Exception {
return setIdentityFeedbackForwardingEnabled(setIdentityFeedbackForwardingEnabledRequest);
}
});
}
/**
*
* Given an identity (email address or domain), enables or disables
* whether Amazon SES forwards bounce and complaint notifications as
* email. Feedback forwarding can only be disabled when Amazon Simple
* Notification Service (Amazon SNS) topics are specified for both
* bounces and complaints.
*
*
* NOTE:Feedback forwarding does not apply to delivery
* notifications. Delivery notifications are only available through
* Amazon SNS.
*
*
* This action is throttled at one request per second.
*
*
* For more information about using notifications with Amazon SES, see
* the
* Amazon SES Developer Guide
* .
*
*
* @param setIdentityFeedbackForwardingEnabledRequest Container for the
* necessary parameters to execute the
* SetIdentityFeedbackForwardingEnabled operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SetIdentityFeedbackForwardingEnabled service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future setIdentityFeedbackForwardingEnabledAsync(
final SetIdentityFeedbackForwardingEnabledRequest setIdentityFeedbackForwardingEnabledRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SetIdentityFeedbackForwardingEnabledResult call() throws Exception {
SetIdentityFeedbackForwardingEnabledResult result;
try {
result = setIdentityFeedbackForwardingEnabled(setIdentityFeedbackForwardingEnabledRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(setIdentityFeedbackForwardingEnabledRequest, result);
return result;
}
});
}
/**
*
* Generates and sends a bounce message to the sender of an email you
* received through Amazon SES. You can only use this API on an email up
* to 24 hours after you receive it.
*
*
* NOTE:You cannot use this API to send generic bounces for mail
* that was not received by Amazon SES.
*
*
* For information about receiving email through Amazon SES, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param sendBounceRequest Container for the necessary parameters to
* execute the SendBounce operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SendBounce service method, as returned by AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future sendBounceAsync(final SendBounceRequest sendBounceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SendBounceResult call() throws Exception {
return sendBounce(sendBounceRequest);
}
});
}
/**
*
* Generates and sends a bounce message to the sender of an email you
* received through Amazon SES. You can only use this API on an email up
* to 24 hours after you receive it.
*
*
* NOTE:You cannot use this API to send generic bounces for mail
* that was not received by Amazon SES.
*
*
* For information about receiving email through Amazon SES, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param sendBounceRequest Container for the necessary parameters to
* execute the SendBounce operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SendBounce service method, as returned by AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future sendBounceAsync(
final SendBounceRequest sendBounceRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SendBounceResult call() throws Exception {
SendBounceResult result;
try {
result = sendBounce(sendBounceRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(sendBounceRequest, result);
return result;
}
});
}
/**
*
* Composes an email message based on input data, and then immediately
* queues the message for sending.
*
*
* There are several important points to know about
* SendEmail :
*
*
*
* - You can only send email from verified email addresses and
* domains; otherwise, you will get an "Email address not verified"
* error. If your account is still in the Amazon SES sandbox, you must
* also verify every recipient email address except for the recipients
* provided by the Amazon SES mailbox simulator. For more information, go
* to the
* Amazon SES Developer Guide
* .
* - The total size of the message cannot exceed 10 MB. This includes
* any attachments that are part of the message.
* - Amazon SES has a limit on the total number of recipients per
* message. The combined number of To:, CC: and BCC: email addresses
* cannot exceed 50. If you need to send an email message to a larger
* audience, you can divide your recipient list into groups of 50 or
* fewer, and then call Amazon SES repeatedly to send the message to each
* group.
* - For every message that you send, the total number of recipients
* (To:, CC: and BCC:) is counted against your sending quota - the
* maximum number of emails you can send in a 24-hour period. For
* information about your sending quota, go to the
* Amazon SES Developer Guide
* .
*
*
*
* @param sendEmailRequest Container for the necessary parameters to
* execute the SendEmail operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* SendEmail service method, as returned by AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future sendEmailAsync(final SendEmailRequest sendEmailRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SendEmailResult call() throws Exception {
return sendEmail(sendEmailRequest);
}
});
}
/**
*
* Composes an email message based on input data, and then immediately
* queues the message for sending.
*
*
* There are several important points to know about
* SendEmail :
*
*
*
* - You can only send email from verified email addresses and
* domains; otherwise, you will get an "Email address not verified"
* error. If your account is still in the Amazon SES sandbox, you must
* also verify every recipient email address except for the recipients
* provided by the Amazon SES mailbox simulator. For more information, go
* to the
* Amazon SES Developer Guide
* .
* - The total size of the message cannot exceed 10 MB. This includes
* any attachments that are part of the message.
* - Amazon SES has a limit on the total number of recipients per
* message. The combined number of To:, CC: and BCC: email addresses
* cannot exceed 50. If you need to send an email message to a larger
* audience, you can divide your recipient list into groups of 50 or
* fewer, and then call Amazon SES repeatedly to send the message to each
* group.
* - For every message that you send, the total number of recipients
* (To:, CC: and BCC:) is counted against your sending quota - the
* maximum number of emails you can send in a 24-hour period. For
* information about your sending quota, go to the
* Amazon SES Developer Guide
* .
*
*
*
* @param sendEmailRequest Container for the necessary parameters to
* execute the SendEmail operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* SendEmail service method, as returned by AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future sendEmailAsync(
final SendEmailRequest sendEmailRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public SendEmailResult call() throws Exception {
SendEmailResult result;
try {
result = sendEmail(sendEmailRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(sendEmailRequest, result);
return result;
}
});
}
/**
*
* Returns a list containing all of the identities (email addresses and
* domains) for a specific AWS Account, regardless of verification
* status.
*
*
* This action is throttled at one request per second.
*
*
* @param listIdentitiesRequest Container for the necessary parameters to
* execute the ListIdentities operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* ListIdentities service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listIdentitiesAsync(final ListIdentitiesRequest listIdentitiesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListIdentitiesResult call() throws Exception {
return listIdentities(listIdentitiesRequest);
}
});
}
/**
*
* Returns a list containing all of the identities (email addresses and
* domains) for a specific AWS Account, regardless of verification
* status.
*
*
* This action is throttled at one request per second.
*
*
* @param listIdentitiesRequest Container for the necessary parameters to
* execute the ListIdentities operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListIdentities service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listIdentitiesAsync(
final ListIdentitiesRequest listIdentitiesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListIdentitiesResult call() throws Exception {
ListIdentitiesResult result;
try {
result = listIdentities(listIdentitiesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listIdentitiesRequest, result);
return result;
}
});
}
/**
*
* Adds or updates a sending authorization policy for the specified
* identity (email address or domain).
*
*
* NOTE:This API is for the identity owner only. If you have not
* verified the identity, this API will return an error.
*
*
* Sending authorization is a feature that enables an identity owner to
* authorize other senders to use its identities. For information about
* using sending authorization, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param putIdentityPolicyRequest Container for the necessary parameters
* to execute the PutIdentityPolicy operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* PutIdentityPolicy service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future putIdentityPolicyAsync(final PutIdentityPolicyRequest putIdentityPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public PutIdentityPolicyResult call() throws Exception {
return putIdentityPolicy(putIdentityPolicyRequest);
}
});
}
/**
*
* Adds or updates a sending authorization policy for the specified
* identity (email address or domain).
*
*
* NOTE:This API is for the identity owner only. If you have not
* verified the identity, this API will return an error.
*
*
* Sending authorization is a feature that enables an identity owner to
* authorize other senders to use its identities. For information about
* using sending authorization, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param putIdentityPolicyRequest Container for the necessary parameters
* to execute the PutIdentityPolicy operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* PutIdentityPolicy service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future putIdentityPolicyAsync(
final PutIdentityPolicyRequest putIdentityPolicyRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public PutIdentityPolicyResult call() throws Exception {
PutIdentityPolicyResult result;
try {
result = putIdentityPolicy(putIdentityPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(putIdentityPolicyRequest, result);
return result;
}
});
}
/**
*
* Verifies an email address. This action causes a confirmation email
* message to be sent to the specified address.
*
*
* IMPORTANT:The VerifyEmailAddress action is deprecated as of
* the May 15, 2012 release of Domain Verification. The
* VerifyEmailIdentity action is now preferred.
*
*
* This action is throttled at one request per second.
*
*
* @param verifyEmailAddressRequest Container for the necessary
* parameters to execute the VerifyEmailAddress operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* VerifyEmailAddress service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future verifyEmailAddressAsync(final VerifyEmailAddressRequest verifyEmailAddressRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public Void call() throws Exception {
verifyEmailAddress(verifyEmailAddressRequest);
return null;
}
});
}
/**
*
* Verifies an email address. This action causes a confirmation email
* message to be sent to the specified address.
*
*
* IMPORTANT:The VerifyEmailAddress action is deprecated as of
* the May 15, 2012 release of Domain Verification. The
* VerifyEmailIdentity action is now preferred.
*
*
* This action is throttled at one request per second.
*
*
* @param verifyEmailAddressRequest Container for the necessary
* parameters to execute the VerifyEmailAddress operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* VerifyEmailAddress service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future verifyEmailAddressAsync(
final VerifyEmailAddressRequest verifyEmailAddressRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public Void call() throws Exception {
try {
verifyEmailAddress(verifyEmailAddressRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(verifyEmailAddressRequest, null);
return null;
}
});
}
/**
*
* Verifies an email address. This action causes a confirmation email
* message to be sent to the specified address.
*
*
* This action is throttled at one request per second.
*
*
* @param verifyEmailIdentityRequest Container for the necessary
* parameters to execute the VerifyEmailIdentity operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* VerifyEmailIdentity service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future verifyEmailIdentityAsync(final VerifyEmailIdentityRequest verifyEmailIdentityRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public VerifyEmailIdentityResult call() throws Exception {
return verifyEmailIdentity(verifyEmailIdentityRequest);
}
});
}
/**
*
* Verifies an email address. This action causes a confirmation email
* message to be sent to the specified address.
*
*
* This action is throttled at one request per second.
*
*
* @param verifyEmailIdentityRequest Container for the necessary
* parameters to execute the VerifyEmailIdentity operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* VerifyEmailIdentity service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future verifyEmailIdentityAsync(
final VerifyEmailIdentityRequest verifyEmailIdentityRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public VerifyEmailIdentityResult call() throws Exception {
VerifyEmailIdentityResult result;
try {
result = verifyEmailIdentity(verifyEmailIdentityRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(verifyEmailIdentityRequest, result);
return result;
}
});
}
/**
*
* Creates an empty receipt rule set.
*
*
* For information about setting up receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param createReceiptRuleSetRequest Container for the necessary
* parameters to execute the CreateReceiptRuleSet operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* CreateReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createReceiptRuleSetAsync(final CreateReceiptRuleSetRequest createReceiptRuleSetRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateReceiptRuleSetResult call() throws Exception {
return createReceiptRuleSet(createReceiptRuleSetRequest);
}
});
}
/**
*
* Creates an empty receipt rule set.
*
*
* For information about setting up receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param createReceiptRuleSetRequest Container for the necessary
* parameters to execute the CreateReceiptRuleSet operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createReceiptRuleSetAsync(
final CreateReceiptRuleSetRequest createReceiptRuleSetRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateReceiptRuleSetResult call() throws Exception {
CreateReceiptRuleSetResult result;
try {
result = createReceiptRuleSet(createReceiptRuleSetRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createReceiptRuleSetRequest, result);
return result;
}
});
}
/**
*
* Deletes the specified sending authorization policy for the given
* identity (email address or domain). This API returns successfully even
* if a policy with the specified name does not exist.
*
*
* NOTE:This API is for the identity owner only. If you have not
* verified the identity, this API will return an error.
*
*
* Sending authorization is a feature that enables an identity owner to
* authorize other senders to use its identities. For information about
* using sending authorization, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param deleteIdentityPolicyRequest Container for the necessary
* parameters to execute the DeleteIdentityPolicy operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DeleteIdentityPolicy service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteIdentityPolicyAsync(final DeleteIdentityPolicyRequest deleteIdentityPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteIdentityPolicyResult call() throws Exception {
return deleteIdentityPolicy(deleteIdentityPolicyRequest);
}
});
}
/**
*
* Deletes the specified sending authorization policy for the given
* identity (email address or domain). This API returns successfully even
* if a policy with the specified name does not exist.
*
*
* NOTE:This API is for the identity owner only. If you have not
* verified the identity, this API will return an error.
*
*
* Sending authorization is a feature that enables an identity owner to
* authorize other senders to use its identities. For information about
* using sending authorization, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param deleteIdentityPolicyRequest Container for the necessary
* parameters to execute the DeleteIdentityPolicy operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteIdentityPolicy service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteIdentityPolicyAsync(
final DeleteIdentityPolicyRequest deleteIdentityPolicyRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteIdentityPolicyResult call() throws Exception {
DeleteIdentityPolicyResult result;
try {
result = deleteIdentityPolicy(deleteIdentityPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteIdentityPolicyRequest, result);
return result;
}
});
}
/**
*
* Returns the user's sending statistics. The result is a list of data
* points, representing the last two weeks of sending activity.
*
*
* Each data point in the list contains statistics for a 15-minute
* interval.
*
*
* This action is throttled at one request per second.
*
*
* @param getSendStatisticsRequest Container for the necessary parameters
* to execute the GetSendStatistics operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* GetSendStatistics service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getSendStatisticsAsync(final GetSendStatisticsRequest getSendStatisticsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetSendStatisticsResult call() throws Exception {
return getSendStatistics(getSendStatisticsRequest);
}
});
}
/**
*
* Returns the user's sending statistics. The result is a list of data
* points, representing the last two weeks of sending activity.
*
*
* Each data point in the list contains statistics for a 15-minute
* interval.
*
*
* This action is throttled at one request per second.
*
*
* @param getSendStatisticsRequest Container for the necessary parameters
* to execute the GetSendStatistics operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetSendStatistics service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getSendStatisticsAsync(
final GetSendStatisticsRequest getSendStatisticsRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetSendStatisticsResult call() throws Exception {
GetSendStatisticsResult result;
try {
result = getSendStatistics(getSendStatisticsRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getSendStatisticsRequest, result);
return result;
}
});
}
/**
*
* Given a list of verified identities (email addresses and/or domains),
* returns a structure describing identity notification attributes.
*
*
* This action is throttled at one request per second and can only get
* notification attributes for up to 100 identities at a time.
*
*
* For more information about using notifications with Amazon SES, see
* the
* Amazon SES Developer Guide
* .
*
*
* @param getIdentityNotificationAttributesRequest Container for the
* necessary parameters to execute the GetIdentityNotificationAttributes
* operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* GetIdentityNotificationAttributes service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityNotificationAttributesAsync(final GetIdentityNotificationAttributesRequest getIdentityNotificationAttributesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityNotificationAttributesResult call() throws Exception {
return getIdentityNotificationAttributes(getIdentityNotificationAttributesRequest);
}
});
}
/**
*
* Given a list of verified identities (email addresses and/or domains),
* returns a structure describing identity notification attributes.
*
*
* This action is throttled at one request per second and can only get
* notification attributes for up to 100 identities at a time.
*
*
* For more information about using notifications with Amazon SES, see
* the
* Amazon SES Developer Guide
* .
*
*
* @param getIdentityNotificationAttributesRequest Container for the
* necessary parameters to execute the GetIdentityNotificationAttributes
* operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetIdentityNotificationAttributes service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getIdentityNotificationAttributesAsync(
final GetIdentityNotificationAttributesRequest getIdentityNotificationAttributesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetIdentityNotificationAttributesResult call() throws Exception {
GetIdentityNotificationAttributesResult result;
try {
result = getIdentityNotificationAttributes(getIdentityNotificationAttributesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getIdentityNotificationAttributesRequest, result);
return result;
}
});
}
/**
*
* Returns the metadata and receipt rules for the receipt rule set that
* is currently active.
*
*
* For information about setting up receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param describeActiveReceiptRuleSetRequest Container for the necessary
* parameters to execute the DescribeActiveReceiptRuleSet operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DescribeActiveReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeActiveReceiptRuleSetAsync(final DescribeActiveReceiptRuleSetRequest describeActiveReceiptRuleSetRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeActiveReceiptRuleSetResult call() throws Exception {
return describeActiveReceiptRuleSet(describeActiveReceiptRuleSetRequest);
}
});
}
/**
*
* Returns the metadata and receipt rules for the receipt rule set that
* is currently active.
*
*
* For information about setting up receipt rule sets, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param describeActiveReceiptRuleSetRequest Container for the necessary
* parameters to execute the DescribeActiveReceiptRuleSet operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DescribeActiveReceiptRuleSet service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeActiveReceiptRuleSetAsync(
final DescribeActiveReceiptRuleSetRequest describeActiveReceiptRuleSetRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeActiveReceiptRuleSetResult call() throws Exception {
DescribeActiveReceiptRuleSetResult result;
try {
result = describeActiveReceiptRuleSet(describeActiveReceiptRuleSetRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(describeActiveReceiptRuleSetRequest, result);
return result;
}
});
}
/**
*
* Returns the details of the specified receipt rule.
*
*
* For information about setting up receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param describeReceiptRuleRequest Container for the necessary
* parameters to execute the DescribeReceiptRule operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* DescribeReceiptRule service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeReceiptRuleAsync(final DescribeReceiptRuleRequest describeReceiptRuleRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeReceiptRuleResult call() throws Exception {
return describeReceiptRule(describeReceiptRuleRequest);
}
});
}
/**
*
* Returns the details of the specified receipt rule.
*
*
* For information about setting up receipt rules, see the
* Amazon SES Developer Guide
* .
*
*
* This action is throttled at one request per second.
*
*
* @param describeReceiptRuleRequest Container for the necessary
* parameters to execute the DescribeReceiptRule operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DescribeReceiptRule service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeReceiptRuleAsync(
final DescribeReceiptRuleRequest describeReceiptRuleRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeReceiptRuleResult call() throws Exception {
DescribeReceiptRuleResult result;
try {
result = describeReceiptRule(describeReceiptRuleRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(describeReceiptRuleRequest, result);
return result;
}
});
}
/**
*
* Returns a list containing all of the email addresses that have been
* verified.
*
*
* IMPORTANT:The ListVerifiedEmailAddresses action is deprecated
* as of the May 15, 2012 release of Domain Verification. The
* ListIdentities action is now preferred.
*
*
* This action is throttled at one request per second.
*
*
* @param listVerifiedEmailAddressesRequest Container for the necessary
* parameters to execute the ListVerifiedEmailAddresses operation on
* AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* ListVerifiedEmailAddresses service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listVerifiedEmailAddressesAsync(final ListVerifiedEmailAddressesRequest listVerifiedEmailAddressesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListVerifiedEmailAddressesResult call() throws Exception {
return listVerifiedEmailAddresses(listVerifiedEmailAddressesRequest);
}
});
}
/**
*
* Returns a list containing all of the email addresses that have been
* verified.
*
*
* IMPORTANT:The ListVerifiedEmailAddresses action is deprecated
* as of the May 15, 2012 release of Domain Verification. The
* ListIdentities action is now preferred.
*
*
* This action is throttled at one request per second.
*
*
* @param listVerifiedEmailAddressesRequest Container for the necessary
* parameters to execute the ListVerifiedEmailAddresses operation on
* AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListVerifiedEmailAddresses service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listVerifiedEmailAddressesAsync(
final ListVerifiedEmailAddressesRequest listVerifiedEmailAddressesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListVerifiedEmailAddressesResult call() throws Exception {
ListVerifiedEmailAddressesResult result;
try {
result = listVerifiedEmailAddresses(listVerifiedEmailAddressesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listVerifiedEmailAddressesRequest, result);
return result;
}
});
}
/**
*
* Returns a set of DKIM tokens for a domain. DKIM tokens are
* character strings that represent your domain's identity. Using these
* tokens, you will need to create DNS CNAME records that point to DKIM
* public keys hosted by Amazon SES. Amazon Web Services will eventually
* detect that you have updated your DNS records; this detection process
* may take up to 72 hours. Upon successful detection, Amazon SES will be
* able to DKIM-sign email originating from that domain.
*
*
* This action is throttled at one request per second.
*
*
* To enable or disable Easy DKIM signing for a domain, use the
* SetIdentityDkimEnabled action.
*
*
* For more information about creating DNS records using DKIM tokens, go
* to the
* Amazon SES Developer Guide
* .
*
*
* @param verifyDomainDkimRequest Container for the necessary parameters
* to execute the VerifyDomainDkim operation on AmazonSimpleEmailService.
*
* @return A Java Future object containing the response from the
* VerifyDomainDkim service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future verifyDomainDkimAsync(final VerifyDomainDkimRequest verifyDomainDkimRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public VerifyDomainDkimResult call() throws Exception {
return verifyDomainDkim(verifyDomainDkimRequest);
}
});
}
/**
*
* Returns a set of DKIM tokens for a domain. DKIM tokens are
* character strings that represent your domain's identity. Using these
* tokens, you will need to create DNS CNAME records that point to DKIM
* public keys hosted by Amazon SES. Amazon Web Services will eventually
* detect that you have updated your DNS records; this detection process
* may take up to 72 hours. Upon successful detection, Amazon SES will be
* able to DKIM-sign email originating from that domain.
*
*
* This action is throttled at one request per second.
*
*
* To enable or disable Easy DKIM signing for a domain, use the
* SetIdentityDkimEnabled action.
*
*
* For more information about creating DNS records using DKIM tokens, go
* to the
* Amazon SES Developer Guide
* .
*
*
* @param verifyDomainDkimRequest Container for the necessary parameters
* to execute the VerifyDomainDkim operation on AmazonSimpleEmailService.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* VerifyDomainDkim service method, as returned by
* AmazonSimpleEmailService.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSimpleEmailService indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future verifyDomainDkimAsync(
final VerifyDomainDkimRequest verifyDomainDkimRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public VerifyDomainDkimResult call() throws Exception {
VerifyDomainDkimResult result;
try {
result = verifyDomainDkim(verifyDomainDkimRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(verifyDomainDkimRequest, result);
return result;
}
});
}
}