com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-ses Show documentation
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.simpleemail;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClientBuilder;
import com.amazonaws.services.simpleemail.waiters.AmazonSimpleEmailServiceWaiters;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.simpleemail.model.*;
import com.amazonaws.services.simpleemail.model.transform.*;
/**
* Client for accessing Amazon SES. All service calls made using this client are blocking, and will not return until the
* service call completes.
*
* Amazon Simple Email Service
*
* This document contains reference information for the Amazon Simple Email
* Service (Amazon SES) API, version 2010-12-01. This document is best used in conjunction with the Amazon SES Developer Guide.
*
*
*
* For a list of Amazon SES endpoints to use in service requests, see Regions and Amazon SES in the Amazon SES Developer Guide.
*
*
*
* This documentation contains reference information related to the following:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
* Common Errors
*
*
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonSimpleEmailServiceClient extends AmazonWebServiceClient implements AmazonSimpleEmailService {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonSimpleEmailService.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "ses";
private volatile AmazonSimpleEmailServiceWaiters waiters;
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
/**
* Map of exception unmarshallers for all modeled exceptions
*/
private final Map> exceptionUnmarshallersMap = new HashMap>();
/**
* List of exception unmarshallers for all modeled exceptions Even though this exceptionUnmarshallers is not used in
* Clients, this is not removed since this was directly used by Client extended classes. Using this list can cause
* performance impact.
*/
protected final List> exceptionUnmarshallers = new ArrayList>();
protected Unmarshaller defaultUnmarshaller;
/**
* Constructs a new client to invoke service methods on Amazon SES. A credentials provider chain will be used that
* searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonSimpleEmailServiceClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonSimpleEmailServiceClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon SES. 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 Amazon SES (ex: proxy settings,
* retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonSimpleEmailServiceClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonSimpleEmailServiceClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on Amazon SES using the specified AWS account credentials.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @deprecated use {@link AmazonSimpleEmailServiceClientBuilder#withCredentials(AWSCredentialsProvider)} for
* example:
* {@code AmazonSimpleEmailServiceClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
public AmazonSimpleEmailServiceClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon SES using the specified AWS account credentials and
* client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon SES (ex: proxy settings,
* retry counts, etc.).
* @deprecated use {@link AmazonSimpleEmailServiceClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonSimpleEmailServiceClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonSimpleEmailServiceClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
/**
* Constructs a new client to invoke service methods on Amazon SES using the specified AWS account credentials
* provider.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @deprecated use {@link AmazonSimpleEmailServiceClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonSimpleEmailServiceClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon SES using the specified AWS account credentials
* provider and client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon SES (ex: proxy settings,
* retry counts, etc.).
* @deprecated use {@link AmazonSimpleEmailServiceClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonSimpleEmailServiceClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonSimpleEmailServiceClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on Amazon SES using the specified AWS account credentials
* provider, client configuration options, and request metric collector.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon SES (ex: proxy settings,
* retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
* @deprecated use {@link AmazonSimpleEmailServiceClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonSimpleEmailServiceClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonSimpleEmailServiceClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AmazonSimpleEmailServiceClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
public static AmazonSimpleEmailServiceClientBuilder builder() {
return AmazonSimpleEmailServiceClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon SES using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonSimpleEmailServiceClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on Amazon SES using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonSimpleEmailServiceClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
if (exceptionUnmarshallersMap.get("InvalidFirehoseDestination") == null) {
exceptionUnmarshallersMap.put("InvalidFirehoseDestination", new InvalidFirehoseDestinationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidFirehoseDestinationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidS3Configuration") == null) {
exceptionUnmarshallersMap.put("InvalidS3Configuration", new InvalidS3ConfigurationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidS3ConfigurationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidDeliveryOptions") == null) {
exceptionUnmarshallersMap.put("InvalidDeliveryOptions", new InvalidDeliveryOptionsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidDeliveryOptionsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidSNSDestination") == null) {
exceptionUnmarshallersMap.put("InvalidSNSDestination", new InvalidSNSDestinationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidSNSDestinationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidRenderingParameter") == null) {
exceptionUnmarshallersMap.put("InvalidRenderingParameter", new InvalidRenderingParameterExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidRenderingParameterExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("MessageRejected") == null) {
exceptionUnmarshallersMap.put("MessageRejected", new MessageRejectedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new MessageRejectedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidCloudWatchDestination") == null) {
exceptionUnmarshallersMap.put("InvalidCloudWatchDestination", new InvalidCloudWatchDestinationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidCloudWatchDestinationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AccountSendingPausedException") == null) {
exceptionUnmarshallersMap.put("AccountSendingPausedException", new AccountSendingPausedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new AccountSendingPausedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("RuleSetDoesNotExist") == null) {
exceptionUnmarshallersMap.put("RuleSetDoesNotExist", new RuleSetDoesNotExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new RuleSetDoesNotExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidSnsTopic") == null) {
exceptionUnmarshallersMap.put("InvalidSnsTopic", new InvalidSnsTopicExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidSnsTopicExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("LimitExceeded") == null) {
exceptionUnmarshallersMap.put("LimitExceeded", new LimitExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new LimitExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ConfigurationSetSendingPausedException") == null) {
exceptionUnmarshallersMap.put("ConfigurationSetSendingPausedException", new ConfigurationSetSendingPausedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ConfigurationSetSendingPausedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("EventDestinationDoesNotExist") == null) {
exceptionUnmarshallersMap.put("EventDestinationDoesNotExist", new EventDestinationDoesNotExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new EventDestinationDoesNotExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidLambdaFunction") == null) {
exceptionUnmarshallersMap.put("InvalidLambdaFunction", new InvalidLambdaFunctionExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidLambdaFunctionExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TemplateDoesNotExist") == null) {
exceptionUnmarshallersMap.put("TemplateDoesNotExist", new TemplateDoesNotExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TemplateDoesNotExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("MissingRenderingAttribute") == null) {
exceptionUnmarshallersMap.put("MissingRenderingAttribute", new MissingRenderingAttributeExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new MissingRenderingAttributeExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AlreadyExists") == null) {
exceptionUnmarshallersMap.put("AlreadyExists", new AlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new AlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CannotDelete") == null) {
exceptionUnmarshallersMap.put("CannotDelete", new CannotDeleteExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CannotDeleteExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TrackingOptionsAlreadyExistsException") == null) {
exceptionUnmarshallersMap.put("TrackingOptionsAlreadyExistsException", new TrackingOptionsAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TrackingOptionsAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ConfigurationSetAlreadyExists") == null) {
exceptionUnmarshallersMap.put("ConfigurationSetAlreadyExists", new ConfigurationSetAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ConfigurationSetAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CustomVerificationEmailInvalidContent") == null) {
exceptionUnmarshallersMap.put("CustomVerificationEmailInvalidContent", new CustomVerificationEmailInvalidContentExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CustomVerificationEmailInvalidContentExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidTemplate") == null) {
exceptionUnmarshallersMap.put("InvalidTemplate", new InvalidTemplateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidTemplateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("MailFromDomainNotVerifiedException") == null) {
exceptionUnmarshallersMap.put("MailFromDomainNotVerifiedException", new MailFromDomainNotVerifiedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new MailFromDomainNotVerifiedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ConfigurationSetDoesNotExist") == null) {
exceptionUnmarshallersMap.put("ConfigurationSetDoesNotExist", new ConfigurationSetDoesNotExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ConfigurationSetDoesNotExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ProductionAccessNotGranted") == null) {
exceptionUnmarshallersMap.put("ProductionAccessNotGranted", new ProductionAccessNotGrantedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ProductionAccessNotGrantedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidTrackingOptions") == null) {
exceptionUnmarshallersMap.put("InvalidTrackingOptions", new InvalidTrackingOptionsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidTrackingOptionsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TrackingOptionsDoesNotExistException") == null) {
exceptionUnmarshallersMap.put("TrackingOptionsDoesNotExistException", new TrackingOptionsDoesNotExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TrackingOptionsDoesNotExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("EventDestinationAlreadyExists") == null) {
exceptionUnmarshallersMap.put("EventDestinationAlreadyExists", new EventDestinationAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new EventDestinationAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("FromEmailAddressNotVerified") == null) {
exceptionUnmarshallersMap.put("FromEmailAddressNotVerified", new FromEmailAddressNotVerifiedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new FromEmailAddressNotVerifiedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("RuleDoesNotExist") == null) {
exceptionUnmarshallersMap.put("RuleDoesNotExist", new RuleDoesNotExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new RuleDoesNotExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidConfigurationSet") == null) {
exceptionUnmarshallersMap.put("InvalidConfigurationSet", new InvalidConfigurationSetExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidConfigurationSetExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CustomVerificationEmailTemplateDoesNotExist") == null) {
exceptionUnmarshallersMap
.put("CustomVerificationEmailTemplateDoesNotExist", new CustomVerificationEmailTemplateDoesNotExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CustomVerificationEmailTemplateDoesNotExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidPolicy") == null) {
exceptionUnmarshallersMap.put("InvalidPolicy", new InvalidPolicyExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidPolicyExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CustomVerificationEmailTemplateAlreadyExists") == null) {
exceptionUnmarshallersMap.put("CustomVerificationEmailTemplateAlreadyExists",
new CustomVerificationEmailTemplateAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CustomVerificationEmailTemplateAlreadyExistsExceptionUnmarshaller());
defaultUnmarshaller = new StandardErrorUnmarshaller(com.amazonaws.services.simpleemail.model.AmazonSimpleEmailServiceException.class);
exceptionUnmarshallers.add(new StandardErrorUnmarshaller(com.amazonaws.services.simpleemail.model.AmazonSimpleEmailServiceException.class));
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
this.setEndpoint("https://email.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/simpleemail/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/simpleemail/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param cloneReceiptRuleSetRequest
* Represents a request to create a receipt rule set by cloning an existing one. You use receipt rule sets to
* receive email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the CloneReceiptRuleSet operation returned by the service.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @throws AlreadyExistsException
* Indicates that a resource could not be created because of a naming conflict.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @sample AmazonSimpleEmailService.CloneReceiptRuleSet
* @see AWS API
* Documentation
*/
@Override
public CloneReceiptRuleSetResult cloneReceiptRuleSet(CloneReceiptRuleSetRequest request) {
request = beforeClientExecution(request);
return executeCloneReceiptRuleSet(request);
}
@SdkInternalApi
final CloneReceiptRuleSetResult executeCloneReceiptRuleSet(CloneReceiptRuleSetRequest cloneReceiptRuleSetRequest) {
ExecutionContext executionContext = createExecutionContext(cloneReceiptRuleSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CloneReceiptRuleSetRequestMarshaller().marshall(super.beforeMarshalling(cloneReceiptRuleSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CloneReceiptRuleSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CloneReceiptRuleSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a configuration set.
*
*
* Configuration sets enable you to publish email sending events. For information about using configuration sets,
* see the Amazon SES Developer
* Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param createConfigurationSetRequest
* Represents a request to create a configuration set. Configuration sets enable you to publish email sending
* events. For information about using configuration sets, see the Amazon SES Developer
* Guide.
* @return Result of the CreateConfigurationSet operation returned by the service.
* @throws ConfigurationSetAlreadyExistsException
* Indicates that the configuration set could not be created because of a naming conflict.
* @throws InvalidConfigurationSetException
* Indicates that the configuration set is invalid. See the error message for details.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @sample AmazonSimpleEmailService.CreateConfigurationSet
* @see AWS
* API Documentation
*/
@Override
public CreateConfigurationSetResult createConfigurationSet(CreateConfigurationSetRequest request) {
request = beforeClientExecution(request);
return executeCreateConfigurationSet(request);
}
@SdkInternalApi
final CreateConfigurationSetResult executeCreateConfigurationSet(CreateConfigurationSetRequest createConfigurationSetRequest) {
ExecutionContext executionContext = createExecutionContext(createConfigurationSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateConfigurationSetRequestMarshaller().marshall(super.beforeMarshalling(createConfigurationSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateConfigurationSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateConfigurationSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a configuration set event destination.
*
*
*
* When you create or update an event destination, you must provide one, and only one, destination. The destination
* can be CloudWatch, Amazon Kinesis Firehose, or Amazon Simple Notification Service (Amazon SNS).
*
*
*
* An event destination is the Amazon Web Services service to which Amazon SES publishes the email sending events
* associated with a configuration set. For information about using configuration sets, see the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param createConfigurationSetEventDestinationRequest
* Represents a request to create a configuration set event destination. A configuration set event
* destination, which can be either Amazon CloudWatch or Amazon Kinesis Firehose, describes an Amazon Web
* Services service in which Amazon SES publishes the email sending events associated with a configuration
* set. For information about using configuration sets, see the Amazon SES Developer
* Guide.
* @return Result of the CreateConfigurationSetEventDestination operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws EventDestinationAlreadyExistsException
* Indicates that the event destination could not be created because of a naming conflict.
* @throws InvalidCloudWatchDestinationException
* Indicates that the Amazon CloudWatch destination is invalid. See the error message for details.
* @throws InvalidFirehoseDestinationException
* Indicates that the Amazon Kinesis Firehose destination is invalid. See the error message for details.
* @throws InvalidSNSDestinationException
* Indicates that the Amazon Simple Notification Service (Amazon SNS) destination is invalid. See the error
* message for details.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @sample AmazonSimpleEmailService.CreateConfigurationSetEventDestination
* @see AWS API Documentation
*/
@Override
public CreateConfigurationSetEventDestinationResult createConfigurationSetEventDestination(CreateConfigurationSetEventDestinationRequest request) {
request = beforeClientExecution(request);
return executeCreateConfigurationSetEventDestination(request);
}
@SdkInternalApi
final CreateConfigurationSetEventDestinationResult executeCreateConfigurationSetEventDestination(
CreateConfigurationSetEventDestinationRequest createConfigurationSetEventDestinationRequest) {
ExecutionContext executionContext = createExecutionContext(createConfigurationSetEventDestinationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateConfigurationSetEventDestinationRequestMarshaller().marshall(super
.beforeMarshalling(createConfigurationSetEventDestinationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateConfigurationSetEventDestination");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateConfigurationSetEventDestinationResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an association between a configuration set and a custom domain for open and click event tracking.
*
*
* By default, images and links used for tracking open and click events are hosted on domains operated by Amazon
* SES. You can configure a subdomain of your own to handle these events. For information about using custom
* domains, see the Amazon SES Developer
* Guide.
*
*
* @param createConfigurationSetTrackingOptionsRequest
* Represents a request to create an open and click tracking option object in a configuration set.
* @return Result of the CreateConfigurationSetTrackingOptions operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws TrackingOptionsAlreadyExistsException
* Indicates that the configuration set you specified already contains a TrackingOptions object.
* @throws InvalidTrackingOptionsException
* Indicates that the custom domain to be used for open and click tracking redirects is invalid. This error
* appears most often in the following situations:
*
* -
*
* When the tracking domain you specified is not verified in Amazon SES.
*
*
* -
*
* When the tracking domain you specified is not a valid domain or subdomain.
*
*
* @sample AmazonSimpleEmailService.CreateConfigurationSetTrackingOptions
* @see AWS API Documentation
*/
@Override
public CreateConfigurationSetTrackingOptionsResult createConfigurationSetTrackingOptions(CreateConfigurationSetTrackingOptionsRequest request) {
request = beforeClientExecution(request);
return executeCreateConfigurationSetTrackingOptions(request);
}
@SdkInternalApi
final CreateConfigurationSetTrackingOptionsResult executeCreateConfigurationSetTrackingOptions(
CreateConfigurationSetTrackingOptionsRequest createConfigurationSetTrackingOptionsRequest) {
ExecutionContext executionContext = createExecutionContext(createConfigurationSetTrackingOptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateConfigurationSetTrackingOptionsRequestMarshaller().marshall(super
.beforeMarshalling(createConfigurationSetTrackingOptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateConfigurationSetTrackingOptions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateConfigurationSetTrackingOptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new custom verification email template.
*
*
* For more information about custom verification email templates, see Using
* Custom Verification Email Templates in the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param createCustomVerificationEmailTemplateRequest
* Represents a request to create a custom verification email template.
* @return Result of the CreateCustomVerificationEmailTemplate operation returned by the service.
* @throws CustomVerificationEmailTemplateAlreadyExistsException
* Indicates that a custom verification email template with the name you specified already exists.
* @throws FromEmailAddressNotVerifiedException
* Indicates that the sender address specified for a custom verification email is not verified, and is
* therefore not eligible to send the custom verification email.
* @throws CustomVerificationEmailInvalidContentException
* Indicates that custom verification email template provided content is invalid.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @sample AmazonSimpleEmailService.CreateCustomVerificationEmailTemplate
* @see AWS API Documentation
*/
@Override
public CreateCustomVerificationEmailTemplateResult createCustomVerificationEmailTemplate(CreateCustomVerificationEmailTemplateRequest request) {
request = beforeClientExecution(request);
return executeCreateCustomVerificationEmailTemplate(request);
}
@SdkInternalApi
final CreateCustomVerificationEmailTemplateResult executeCreateCustomVerificationEmailTemplate(
CreateCustomVerificationEmailTemplateRequest createCustomVerificationEmailTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(createCustomVerificationEmailTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCustomVerificationEmailTemplateRequestMarshaller().marshall(super
.beforeMarshalling(createCustomVerificationEmailTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCustomVerificationEmailTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateCustomVerificationEmailTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new IP address filter.
*
*
* For information about setting up IP address filters, see the Amazon SES
* Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param createReceiptFilterRequest
* Represents a request to create a new IP address filter. You use IP address filters when you receive email
* with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the CreateReceiptFilter operation returned by the service.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @throws AlreadyExistsException
* Indicates that a resource could not be created because of a naming conflict.
* @sample AmazonSimpleEmailService.CreateReceiptFilter
* @see AWS API
* Documentation
*/
@Override
public CreateReceiptFilterResult createReceiptFilter(CreateReceiptFilterRequest request) {
request = beforeClientExecution(request);
return executeCreateReceiptFilter(request);
}
@SdkInternalApi
final CreateReceiptFilterResult executeCreateReceiptFilter(CreateReceiptFilterRequest createReceiptFilterRequest) {
ExecutionContext executionContext = createExecutionContext(createReceiptFilterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateReceiptFilterRequestMarshaller().marshall(super.beforeMarshalling(createReceiptFilterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateReceiptFilter");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateReceiptFilterResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a receipt rule.
*
*
* For information about setting up receipt rules, see the Amazon
* SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param createReceiptRuleRequest
* Represents a request to create a receipt rule. You use receipt rules to receive email with Amazon SES. For
* more information, see the Amazon SES Developer
* Guide.
* @return Result of the CreateReceiptRule operation returned by the service.
* @throws InvalidSnsTopicException
* Indicates that the provided Amazon SNS topic is invalid, or that Amazon SES could not publish to the
* topic, possibly due to permissions issues. For information about giving permissions, see the Amazon SES
* Developer Guide.
* @throws InvalidS3ConfigurationException
* Indicates that the provided Amazon S3 bucket or Amazon Web Services KMS encryption key is invalid, or
* that Amazon SES could not publish to the bucket, possibly due to permissions issues. For information
* about giving permissions, see the Amazon SES
* Developer Guide.
* @throws InvalidLambdaFunctionException
* Indicates that the provided Amazon Web Services Lambda function is invalid, or that Amazon SES could not
* execute the provided function, possibly due to permissions issues. For information about giving
* permissions, see the Amazon SES
* Developer Guide.
* @throws AlreadyExistsException
* Indicates that a resource could not be created because of a naming conflict.
* @throws RuleDoesNotExistException
* Indicates that the provided receipt rule does not exist.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @sample AmazonSimpleEmailService.CreateReceiptRule
* @see AWS API
* Documentation
*/
@Override
public CreateReceiptRuleResult createReceiptRule(CreateReceiptRuleRequest request) {
request = beforeClientExecution(request);
return executeCreateReceiptRule(request);
}
@SdkInternalApi
final CreateReceiptRuleResult executeCreateReceiptRule(CreateReceiptRuleRequest createReceiptRuleRequest) {
ExecutionContext executionContext = createExecutionContext(createReceiptRuleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateReceiptRuleRequestMarshaller().marshall(super.beforeMarshalling(createReceiptRuleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateReceiptRule");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateReceiptRuleResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an empty receipt rule set.
*
*
* For information about setting up receipt rule sets, see the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param createReceiptRuleSetRequest
* Represents a request to create an empty receipt rule set. You use receipt rule sets to receive email with
* Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the CreateReceiptRuleSet operation returned by the service.
* @throws AlreadyExistsException
* Indicates that a resource could not be created because of a naming conflict.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @sample AmazonSimpleEmailService.CreateReceiptRuleSet
* @see AWS API
* Documentation
*/
@Override
public CreateReceiptRuleSetResult createReceiptRuleSet(CreateReceiptRuleSetRequest request) {
request = beforeClientExecution(request);
return executeCreateReceiptRuleSet(request);
}
@SdkInternalApi
final CreateReceiptRuleSetResult executeCreateReceiptRuleSet(CreateReceiptRuleSetRequest createReceiptRuleSetRequest) {
ExecutionContext executionContext = createExecutionContext(createReceiptRuleSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateReceiptRuleSetRequestMarshaller().marshall(super.beforeMarshalling(createReceiptRuleSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateReceiptRuleSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateReceiptRuleSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an email template. Email templates enable you to send personalized email to one or more destinations in a
* single operation. For more information, see the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param createTemplateRequest
* Represents a request to create an email template. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the CreateTemplate operation returned by the service.
* @throws AlreadyExistsException
* Indicates that a resource could not be created because of a naming conflict.
* @throws InvalidTemplateException
* Indicates that the template that you specified could not be rendered. This issue may occur when a
* template refers to a partial that does not exist.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @sample AmazonSimpleEmailService.CreateTemplate
* @see AWS API
* Documentation
*/
@Override
public CreateTemplateResult createTemplate(CreateTemplateRequest request) {
request = beforeClientExecution(request);
return executeCreateTemplate(request);
}
@SdkInternalApi
final CreateTemplateResult executeCreateTemplate(CreateTemplateRequest createTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(createTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateTemplateRequestMarshaller().marshall(super.beforeMarshalling(createTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a configuration set. Configuration sets enable you to publish email sending events. For information about
* using configuration sets, see the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteConfigurationSetRequest
* Represents a request to delete a configuration set. Configuration sets enable you to publish email sending
* events. For information about using configuration sets, see the Amazon SES Developer
* Guide.
* @return Result of the DeleteConfigurationSet operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @sample AmazonSimpleEmailService.DeleteConfigurationSet
* @see AWS
* API Documentation
*/
@Override
public DeleteConfigurationSetResult deleteConfigurationSet(DeleteConfigurationSetRequest request) {
request = beforeClientExecution(request);
return executeDeleteConfigurationSet(request);
}
@SdkInternalApi
final DeleteConfigurationSetResult executeDeleteConfigurationSet(DeleteConfigurationSetRequest deleteConfigurationSetRequest) {
ExecutionContext executionContext = createExecutionContext(deleteConfigurationSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteConfigurationSetRequestMarshaller().marshall(super.beforeMarshalling(deleteConfigurationSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteConfigurationSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteConfigurationSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a configuration set event destination. Configuration set event destinations are associated with
* configuration sets, which enable you to publish email sending events. For information about using configuration
* sets, see the Amazon SES
* Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteConfigurationSetEventDestinationRequest
* Represents a request to delete a configuration set event destination. Configuration set event destinations
* are associated with configuration sets, which enable you to publish email sending events. For information
* about using configuration sets, see the Amazon SES Developer
* Guide.
* @return Result of the DeleteConfigurationSetEventDestination operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws EventDestinationDoesNotExistException
* Indicates that the event destination does not exist.
* @sample AmazonSimpleEmailService.DeleteConfigurationSetEventDestination
* @see AWS API Documentation
*/
@Override
public DeleteConfigurationSetEventDestinationResult deleteConfigurationSetEventDestination(DeleteConfigurationSetEventDestinationRequest request) {
request = beforeClientExecution(request);
return executeDeleteConfigurationSetEventDestination(request);
}
@SdkInternalApi
final DeleteConfigurationSetEventDestinationResult executeDeleteConfigurationSetEventDestination(
DeleteConfigurationSetEventDestinationRequest deleteConfigurationSetEventDestinationRequest) {
ExecutionContext executionContext = createExecutionContext(deleteConfigurationSetEventDestinationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteConfigurationSetEventDestinationRequestMarshaller().marshall(super
.beforeMarshalling(deleteConfigurationSetEventDestinationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteConfigurationSetEventDestination");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteConfigurationSetEventDestinationResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an association between a configuration set and a custom domain for open and click event tracking.
*
*
* By default, images and links used for tracking open and click events are hosted on domains operated by Amazon
* SES. You can configure a subdomain of your own to handle these events. For information about using custom
* domains, see the Amazon SES Developer
* Guide.
*
*
*
* Deleting this kind of association results in emails sent using the specified configuration set to capture open
* and click events using the standard, Amazon SES-operated domains.
*
*
*
* @param deleteConfigurationSetTrackingOptionsRequest
* Represents a request to delete open and click tracking options in a configuration set.
* @return Result of the DeleteConfigurationSetTrackingOptions operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws TrackingOptionsDoesNotExistException
* Indicates that the TrackingOptions object you specified does not exist.
* @sample AmazonSimpleEmailService.DeleteConfigurationSetTrackingOptions
* @see AWS API Documentation
*/
@Override
public DeleteConfigurationSetTrackingOptionsResult deleteConfigurationSetTrackingOptions(DeleteConfigurationSetTrackingOptionsRequest request) {
request = beforeClientExecution(request);
return executeDeleteConfigurationSetTrackingOptions(request);
}
@SdkInternalApi
final DeleteConfigurationSetTrackingOptionsResult executeDeleteConfigurationSetTrackingOptions(
DeleteConfigurationSetTrackingOptionsRequest deleteConfigurationSetTrackingOptionsRequest) {
ExecutionContext executionContext = createExecutionContext(deleteConfigurationSetTrackingOptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteConfigurationSetTrackingOptionsRequestMarshaller().marshall(super
.beforeMarshalling(deleteConfigurationSetTrackingOptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteConfigurationSetTrackingOptions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteConfigurationSetTrackingOptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an existing custom verification email template.
*
*
* For more information about custom verification email templates, see Using
* Custom Verification Email Templates in the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteCustomVerificationEmailTemplateRequest
* Represents a request to delete an existing custom verification email template.
* @return Result of the DeleteCustomVerificationEmailTemplate operation returned by the service.
* @sample AmazonSimpleEmailService.DeleteCustomVerificationEmailTemplate
* @see AWS API Documentation
*/
@Override
public DeleteCustomVerificationEmailTemplateResult deleteCustomVerificationEmailTemplate(DeleteCustomVerificationEmailTemplateRequest request) {
request = beforeClientExecution(request);
return executeDeleteCustomVerificationEmailTemplate(request);
}
@SdkInternalApi
final DeleteCustomVerificationEmailTemplateResult executeDeleteCustomVerificationEmailTemplate(
DeleteCustomVerificationEmailTemplateRequest deleteCustomVerificationEmailTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(deleteCustomVerificationEmailTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCustomVerificationEmailTemplateRequestMarshaller().marshall(super
.beforeMarshalling(deleteCustomVerificationEmailTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteCustomVerificationEmailTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteCustomVerificationEmailTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified identity (an email address or a domain) from the list of verified identities.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteIdentityRequest
* Represents a request to delete one of your Amazon SES identities (an email address or domain).
* @return Result of the DeleteIdentity operation returned by the service.
* @sample AmazonSimpleEmailService.DeleteIdentity
* @see AWS API
* Documentation
*/
@Override
public DeleteIdentityResult deleteIdentity(DeleteIdentityRequest request) {
request = beforeClientExecution(request);
return executeDeleteIdentity(request);
}
@SdkInternalApi
final DeleteIdentityResult executeDeleteIdentity(DeleteIdentityRequest deleteIdentityRequest) {
ExecutionContext executionContext = createExecutionContext(deleteIdentityRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteIdentityRequestMarshaller().marshall(super.beforeMarshalling(deleteIdentityRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteIdentity");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteIdentityResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified sending authorization policy for the given identity (an email address or a domain). This
* operation returns successfully even if a policy with the specified name does not exist.
*
*
*
* This operation is for the identity owner only. If you have not verified the identity, it returns 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteIdentityPolicyRequest
* Represents a request to delete a sending authorization policy for an identity. Sending authorization is an
* Amazon SES feature that enables you to authorize other senders to use your identities. For information,
* see the Amazon SES
* Developer Guide.
* @return Result of the DeleteIdentityPolicy operation returned by the service.
* @sample AmazonSimpleEmailService.DeleteIdentityPolicy
* @see AWS API
* Documentation
*/
@Override
public DeleteIdentityPolicyResult deleteIdentityPolicy(DeleteIdentityPolicyRequest request) {
request = beforeClientExecution(request);
return executeDeleteIdentityPolicy(request);
}
@SdkInternalApi
final DeleteIdentityPolicyResult executeDeleteIdentityPolicy(DeleteIdentityPolicyRequest deleteIdentityPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(deleteIdentityPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteIdentityPolicyRequestMarshaller().marshall(super.beforeMarshalling(deleteIdentityPolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteIdentityPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteIdentityPolicyResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified IP address filter.
*
*
* For information about managing IP address filters, see the Amazon SES
* Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteReceiptFilterRequest
* Represents a request to delete an IP address filter. You use IP address filters when you receive email
* with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the DeleteReceiptFilter operation returned by the service.
* @sample AmazonSimpleEmailService.DeleteReceiptFilter
* @see AWS API
* Documentation
*/
@Override
public DeleteReceiptFilterResult deleteReceiptFilter(DeleteReceiptFilterRequest request) {
request = beforeClientExecution(request);
return executeDeleteReceiptFilter(request);
}
@SdkInternalApi
final DeleteReceiptFilterResult executeDeleteReceiptFilter(DeleteReceiptFilterRequest deleteReceiptFilterRequest) {
ExecutionContext executionContext = createExecutionContext(deleteReceiptFilterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteReceiptFilterRequestMarshaller().marshall(super.beforeMarshalling(deleteReceiptFilterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteReceiptFilter");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteReceiptFilterResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified receipt rule.
*
*
* For information about managing receipt rules, see the Amazon
* SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteReceiptRuleRequest
* Represents a request to delete a receipt rule. You use receipt rules to receive email with Amazon SES. For
* more information, see the Amazon SES Developer
* Guide.
* @return Result of the DeleteReceiptRule operation returned by the service.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @sample AmazonSimpleEmailService.DeleteReceiptRule
* @see AWS API
* Documentation
*/
@Override
public DeleteReceiptRuleResult deleteReceiptRule(DeleteReceiptRuleRequest request) {
request = beforeClientExecution(request);
return executeDeleteReceiptRule(request);
}
@SdkInternalApi
final DeleteReceiptRuleResult executeDeleteReceiptRule(DeleteReceiptRuleRequest deleteReceiptRuleRequest) {
ExecutionContext executionContext = createExecutionContext(deleteReceiptRuleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteReceiptRuleRequestMarshaller().marshall(super.beforeMarshalling(deleteReceiptRuleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteReceiptRule");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteReceiptRuleResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified receipt rule set and all of the receipt rules it contains.
*
*
*
* The currently active rule set cannot be deleted.
*
*
*
* For information about managing receipt rule sets, see the Amazon
* SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteReceiptRuleSetRequest
* Represents a request to delete a receipt rule set and all of the receipt rules it contains. You use
* receipt rule sets to receive email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the DeleteReceiptRuleSet operation returned by the service.
* @throws CannotDeleteException
* Indicates that the delete operation could not be completed.
* @sample AmazonSimpleEmailService.DeleteReceiptRuleSet
* @see AWS API
* Documentation
*/
@Override
public DeleteReceiptRuleSetResult deleteReceiptRuleSet(DeleteReceiptRuleSetRequest request) {
request = beforeClientExecution(request);
return executeDeleteReceiptRuleSet(request);
}
@SdkInternalApi
final DeleteReceiptRuleSetResult executeDeleteReceiptRuleSet(DeleteReceiptRuleSetRequest deleteReceiptRuleSetRequest) {
ExecutionContext executionContext = createExecutionContext(deleteReceiptRuleSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteReceiptRuleSetRequestMarshaller().marshall(super.beforeMarshalling(deleteReceiptRuleSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteReceiptRuleSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteReceiptRuleSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an email template.
*
*
* You can execute this operation no more than once per second.
*
*
* @param deleteTemplateRequest
* Represents a request to delete an email template. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the DeleteTemplate operation returned by the service.
* @sample AmazonSimpleEmailService.DeleteTemplate
* @see AWS API
* Documentation
*/
@Override
public DeleteTemplateResult deleteTemplate(DeleteTemplateRequest request) {
request = beforeClientExecution(request);
return executeDeleteTemplate(request);
}
@SdkInternalApi
final DeleteTemplateResult executeDeleteTemplate(DeleteTemplateRequest deleteTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(deleteTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteTemplateRequestMarshaller().marshall(super.beforeMarshalling(deleteTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deprecated. Use the DeleteIdentity operation to delete email addresses and domains.
*
*
* @param deleteVerifiedEmailAddressRequest
* Represents a request to delete an email address from the list of email addresses you have attempted to
* verify under your Amazon Web Services account.
* @return Result of the DeleteVerifiedEmailAddress operation returned by the service.
* @sample AmazonSimpleEmailService.DeleteVerifiedEmailAddress
* @see AWS API Documentation
*/
@Override
public DeleteVerifiedEmailAddressResult deleteVerifiedEmailAddress(DeleteVerifiedEmailAddressRequest request) {
request = beforeClientExecution(request);
return executeDeleteVerifiedEmailAddress(request);
}
@SdkInternalApi
final DeleteVerifiedEmailAddressResult executeDeleteVerifiedEmailAddress(DeleteVerifiedEmailAddressRequest deleteVerifiedEmailAddressRequest) {
ExecutionContext executionContext = createExecutionContext(deleteVerifiedEmailAddressRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteVerifiedEmailAddressRequestMarshaller().marshall(super.beforeMarshalling(deleteVerifiedEmailAddressRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteVerifiedEmailAddress");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteVerifiedEmailAddressResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param describeActiveReceiptRuleSetRequest
* Represents a request to return the metadata and receipt rules for the receipt rule set that is currently
* active. You use receipt rule sets to receive email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the DescribeActiveReceiptRuleSet operation returned by the service.
* @sample AmazonSimpleEmailService.DescribeActiveReceiptRuleSet
* @see AWS API Documentation
*/
@Override
public DescribeActiveReceiptRuleSetResult describeActiveReceiptRuleSet(DescribeActiveReceiptRuleSetRequest request) {
request = beforeClientExecution(request);
return executeDescribeActiveReceiptRuleSet(request);
}
@SdkInternalApi
final DescribeActiveReceiptRuleSetResult executeDescribeActiveReceiptRuleSet(DescribeActiveReceiptRuleSetRequest describeActiveReceiptRuleSetRequest) {
ExecutionContext executionContext = createExecutionContext(describeActiveReceiptRuleSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeActiveReceiptRuleSetRequestMarshaller().marshall(super.beforeMarshalling(describeActiveReceiptRuleSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeActiveReceiptRuleSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeActiveReceiptRuleSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the details of the specified configuration set. For information about using configuration sets, see the
* Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param describeConfigurationSetRequest
* Represents a request to return the details of a configuration set. Configuration sets enable you to
* publish email sending events. For information about using configuration sets, see the Amazon SES Developer
* Guide.
* @return Result of the DescribeConfigurationSet operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @sample AmazonSimpleEmailService.DescribeConfigurationSet
* @see AWS
* API Documentation
*/
@Override
public DescribeConfigurationSetResult describeConfigurationSet(DescribeConfigurationSetRequest request) {
request = beforeClientExecution(request);
return executeDescribeConfigurationSet(request);
}
@SdkInternalApi
final DescribeConfigurationSetResult executeDescribeConfigurationSet(DescribeConfigurationSetRequest describeConfigurationSetRequest) {
ExecutionContext executionContext = createExecutionContext(describeConfigurationSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeConfigurationSetRequestMarshaller().marshall(super.beforeMarshalling(describeConfigurationSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeConfigurationSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeConfigurationSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the details of the specified receipt rule.
*
*
* For information about setting up receipt rules, see the Amazon
* SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param describeReceiptRuleRequest
* Represents a request to return the details of a receipt rule. You use receipt rules to receive email with
* Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the DescribeReceiptRule operation returned by the service.
* @throws RuleDoesNotExistException
* Indicates that the provided receipt rule does not exist.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @sample AmazonSimpleEmailService.DescribeReceiptRule
* @see AWS API
* Documentation
*/
@Override
public DescribeReceiptRuleResult describeReceiptRule(DescribeReceiptRuleRequest request) {
request = beforeClientExecution(request);
return executeDescribeReceiptRule(request);
}
@SdkInternalApi
final DescribeReceiptRuleResult executeDescribeReceiptRule(DescribeReceiptRuleRequest describeReceiptRuleRequest) {
ExecutionContext executionContext = createExecutionContext(describeReceiptRuleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeReceiptRuleRequestMarshaller().marshall(super.beforeMarshalling(describeReceiptRuleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeReceiptRule");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeReceiptRuleResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the details of the specified receipt rule set.
*
*
* For information about managing receipt rule sets, see the Amazon
* SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param describeReceiptRuleSetRequest
* Represents a request to return the details of a receipt rule set. You use receipt rule sets to receive
* email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the DescribeReceiptRuleSet operation returned by the service.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @sample AmazonSimpleEmailService.DescribeReceiptRuleSet
* @see AWS
* API Documentation
*/
@Override
public DescribeReceiptRuleSetResult describeReceiptRuleSet(DescribeReceiptRuleSetRequest request) {
request = beforeClientExecution(request);
return executeDescribeReceiptRuleSet(request);
}
@SdkInternalApi
final DescribeReceiptRuleSetResult executeDescribeReceiptRuleSet(DescribeReceiptRuleSetRequest describeReceiptRuleSetRequest) {
ExecutionContext executionContext = createExecutionContext(describeReceiptRuleSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeReceiptRuleSetRequestMarshaller().marshall(super.beforeMarshalling(describeReceiptRuleSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeReceiptRuleSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeReceiptRuleSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the email sending status of the Amazon SES account for the current Region.
*
*
* You can execute this operation no more than once per second.
*
*
* @param getAccountSendingEnabledRequest
* @return Result of the GetAccountSendingEnabled operation returned by the service.
* @sample AmazonSimpleEmailService.GetAccountSendingEnabled
* @see AWS
* API Documentation
*/
@Override
public GetAccountSendingEnabledResult getAccountSendingEnabled(GetAccountSendingEnabledRequest request) {
request = beforeClientExecution(request);
return executeGetAccountSendingEnabled(request);
}
@SdkInternalApi
final GetAccountSendingEnabledResult executeGetAccountSendingEnabled(GetAccountSendingEnabledRequest getAccountSendingEnabledRequest) {
ExecutionContext executionContext = createExecutionContext(getAccountSendingEnabledRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetAccountSendingEnabledRequestMarshaller().marshall(super.beforeMarshalling(getAccountSendingEnabledRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetAccountSendingEnabled");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetAccountSendingEnabledResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the custom email verification template for the template name you specify.
*
*
* For more information about custom verification email templates, see Using
* Custom Verification Email Templates in the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param getCustomVerificationEmailTemplateRequest
* Represents a request to retrieve an existing custom verification email template.
* @return Result of the GetCustomVerificationEmailTemplate operation returned by the service.
* @throws CustomVerificationEmailTemplateDoesNotExistException
* Indicates that a custom verification email template with the name you specified does not exist.
* @sample AmazonSimpleEmailService.GetCustomVerificationEmailTemplate
* @see AWS API Documentation
*/
@Override
public GetCustomVerificationEmailTemplateResult getCustomVerificationEmailTemplate(GetCustomVerificationEmailTemplateRequest request) {
request = beforeClientExecution(request);
return executeGetCustomVerificationEmailTemplate(request);
}
@SdkInternalApi
final GetCustomVerificationEmailTemplateResult executeGetCustomVerificationEmailTemplate(
GetCustomVerificationEmailTemplateRequest getCustomVerificationEmailTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(getCustomVerificationEmailTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetCustomVerificationEmailTemplateRequestMarshaller()
.marshall(super.beforeMarshalling(getCustomVerificationEmailTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetCustomVerificationEmailTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetCustomVerificationEmailTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the current status of Easy DKIM signing for an entity. For domain name identities, this operation 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 operation 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 operation 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
* Represents a request for the status of Amazon SES Easy DKIM signing for an identity. For domain
* identities, this request also returns the DKIM tokens that are required for Easy DKIM signing, and whether
* Amazon SES successfully verified that these tokens were published. For more information about Easy DKIM,
* see the Amazon SES
* Developer Guide.
* @return Result of the GetIdentityDkimAttributes operation returned by the service.
* @sample AmazonSimpleEmailService.GetIdentityDkimAttributes
* @see AWS API Documentation
*/
@Override
public GetIdentityDkimAttributesResult getIdentityDkimAttributes(GetIdentityDkimAttributesRequest request) {
request = beforeClientExecution(request);
return executeGetIdentityDkimAttributes(request);
}
@SdkInternalApi
final GetIdentityDkimAttributesResult executeGetIdentityDkimAttributes(GetIdentityDkimAttributesRequest getIdentityDkimAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(getIdentityDkimAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetIdentityDkimAttributesRequestMarshaller().marshall(super.beforeMarshalling(getIdentityDkimAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetIdentityDkimAttributes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetIdentityDkimAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the custom MAIL FROM attributes for a list of identities (email addresses : domains).
*
*
* This operation 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
* Represents a request to return the Amazon SES custom MAIL FROM attributes for a list of identities. For
* information about using a custom MAIL FROM domain, see the Amazon SES Developer Guide.
* @return Result of the GetIdentityMailFromDomainAttributes operation returned by the service.
* @sample AmazonSimpleEmailService.GetIdentityMailFromDomainAttributes
* @see AWS API Documentation
*/
@Override
public GetIdentityMailFromDomainAttributesResult getIdentityMailFromDomainAttributes(GetIdentityMailFromDomainAttributesRequest request) {
request = beforeClientExecution(request);
return executeGetIdentityMailFromDomainAttributes(request);
}
@SdkInternalApi
final GetIdentityMailFromDomainAttributesResult executeGetIdentityMailFromDomainAttributes(
GetIdentityMailFromDomainAttributesRequest getIdentityMailFromDomainAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(getIdentityMailFromDomainAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetIdentityMailFromDomainAttributesRequestMarshaller().marshall(super
.beforeMarshalling(getIdentityMailFromDomainAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetIdentityMailFromDomainAttributes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetIdentityMailFromDomainAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Given a list of verified identities (email addresses and/or domains), returns a structure describing identity
* notification attributes.
*
*
* This operation 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
* Represents a request to return the notification attributes for a list of identities you verified with
* Amazon SES. For information about Amazon SES notifications, see the Amazon
* SES Developer Guide.
* @return Result of the GetIdentityNotificationAttributes operation returned by the service.
* @sample AmazonSimpleEmailService.GetIdentityNotificationAttributes
* @see AWS API Documentation
*/
@Override
public GetIdentityNotificationAttributesResult getIdentityNotificationAttributes(GetIdentityNotificationAttributesRequest request) {
request = beforeClientExecution(request);
return executeGetIdentityNotificationAttributes(request);
}
@SdkInternalApi
final GetIdentityNotificationAttributesResult executeGetIdentityNotificationAttributes(
GetIdentityNotificationAttributesRequest getIdentityNotificationAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(getIdentityNotificationAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetIdentityNotificationAttributesRequestMarshaller().marshall(super.beforeMarshalling(getIdentityNotificationAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetIdentityNotificationAttributes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetIdentityNotificationAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the requested sending authorization policies for the given identity (an email address or a 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.
*
*
*
* This operation is for the identity owner only. If you have not verified the identity, it returns 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param getIdentityPoliciesRequest
* Represents a request to return the requested sending authorization policies for an identity. Sending
* authorization is an Amazon SES feature that enables you to authorize other senders to use your identities.
* For information, see the Amazon SES Developer
* Guide.
* @return Result of the GetIdentityPolicies operation returned by the service.
* @sample AmazonSimpleEmailService.GetIdentityPolicies
* @see AWS API
* Documentation
*/
@Override
public GetIdentityPoliciesResult getIdentityPolicies(GetIdentityPoliciesRequest request) {
request = beforeClientExecution(request);
return executeGetIdentityPolicies(request);
}
@SdkInternalApi
final GetIdentityPoliciesResult executeGetIdentityPolicies(GetIdentityPoliciesRequest getIdentityPoliciesRequest) {
ExecutionContext executionContext = createExecutionContext(getIdentityPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetIdentityPoliciesRequestMarshaller().marshall(super.beforeMarshalling(getIdentityPoliciesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetIdentityPolicies");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetIdentityPoliciesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Given a list of identities (email addresses and/or domains), returns the verification status and (for domain
* identities) the verification token for each identity.
*
*
* The verification status of an email address is "Pending" until the email address owner clicks the link within the
* verification email that Amazon SES sent to that address. If the email address owner clicks the link within 24
* hours, the verification status of the email address changes to "Success". If the link is not clicked within 24
* hours, the verification status changes to "Failed." In that case, to verify the email address, you must restart
* the verification process from the beginning.
*
*
* For domain identities, the domain's verification status is "Pending" as Amazon SES searches for the required TXT
* record in the DNS settings of the domain. When Amazon SES detects the record, the domain's verification status
* changes to "Success". If Amazon SES is unable to detect the record within 72 hours, the domain's verification
* status changes to "Failed." In that case, to verify the domain, you must restart the verification process from
* the beginning.
*
*
* This operation is throttled at one request per second and can only get verification attributes for up to 100
* identities at a time.
*
*
* @param getIdentityVerificationAttributesRequest
* Represents a request to return the Amazon SES verification status of a list of identities. For domain
* identities, this request also returns the verification token. For information about verifying identities
* with Amazon SES, see the Amazon SES Developer Guide.
* @return Result of the GetIdentityVerificationAttributes operation returned by the service.
* @sample AmazonSimpleEmailService.GetIdentityVerificationAttributes
* @see AWS API Documentation
*/
@Override
public GetIdentityVerificationAttributesResult getIdentityVerificationAttributes(GetIdentityVerificationAttributesRequest request) {
request = beforeClientExecution(request);
return executeGetIdentityVerificationAttributes(request);
}
@SdkInternalApi
final GetIdentityVerificationAttributesResult executeGetIdentityVerificationAttributes(
GetIdentityVerificationAttributesRequest getIdentityVerificationAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(getIdentityVerificationAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetIdentityVerificationAttributesRequestMarshaller().marshall(super.beforeMarshalling(getIdentityVerificationAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetIdentityVerificationAttributes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetIdentityVerificationAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides the sending limits for the Amazon SES account.
*
*
* You can execute this operation no more than once per second.
*
*
* @param getSendQuotaRequest
* @return Result of the GetSendQuota operation returned by the service.
* @sample AmazonSimpleEmailService.GetSendQuota
* @see AWS API
* Documentation
*/
@Override
public GetSendQuotaResult getSendQuota(GetSendQuotaRequest request) {
request = beforeClientExecution(request);
return executeGetSendQuota(request);
}
@SdkInternalApi
final GetSendQuotaResult executeGetSendQuota(GetSendQuotaRequest getSendQuotaRequest) {
ExecutionContext executionContext = createExecutionContext(getSendQuotaRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetSendQuotaRequestMarshaller().marshall(super.beforeMarshalling(getSendQuotaRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetSendQuota");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new GetSendQuotaResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public GetSendQuotaResult getSendQuota() {
return getSendQuota(new GetSendQuotaRequest());
}
/**
*
* Provides sending statistics for the current Amazon Web Services Region. 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 period of time.
*
*
* You can execute this operation no more than once per second.
*
*
* @param getSendStatisticsRequest
* @return Result of the GetSendStatistics operation returned by the service.
* @sample AmazonSimpleEmailService.GetSendStatistics
* @see AWS API
* Documentation
*/
@Override
public GetSendStatisticsResult getSendStatistics(GetSendStatisticsRequest request) {
request = beforeClientExecution(request);
return executeGetSendStatistics(request);
}
@SdkInternalApi
final GetSendStatisticsResult executeGetSendStatistics(GetSendStatisticsRequest getSendStatisticsRequest) {
ExecutionContext executionContext = createExecutionContext(getSendStatisticsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetSendStatisticsRequestMarshaller().marshall(super.beforeMarshalling(getSendStatisticsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetSendStatistics");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetSendStatisticsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public GetSendStatisticsResult getSendStatistics() {
return getSendStatistics(new GetSendStatisticsRequest());
}
/**
*
* Displays the template object (which includes the Subject line, HTML part and text part) for the template you
* specify.
*
*
* You can execute this operation no more than once per second.
*
*
* @param getTemplateRequest
* @return Result of the GetTemplate operation returned by the service.
* @throws TemplateDoesNotExistException
* Indicates that the Template object you specified does not exist in your Amazon SES account.
* @sample AmazonSimpleEmailService.GetTemplate
* @see AWS API
* Documentation
*/
@Override
public GetTemplateResult getTemplate(GetTemplateRequest request) {
request = beforeClientExecution(request);
return executeGetTemplate(request);
}
@SdkInternalApi
final GetTemplateResult executeGetTemplate(GetTemplateRequest getTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(getTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetTemplateRequestMarshaller().marshall(super.beforeMarshalling(getTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new GetTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides a list of the configuration sets associated with your Amazon SES account in the current Amazon Web
* Services Region. For information about using configuration sets, see Monitoring Your Amazon SES Sending
* Activity in the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second. This operation returns up to 1,000 configuration
* sets each time it is run. If your Amazon SES account has more than 1,000 configuration sets, this operation also
* returns NextToken. You can then execute the ListConfigurationSets operation again,
* passing the NextToken parameter and the value of the NextToken element to retrieve additional
* results.
*
*
* @param listConfigurationSetsRequest
* Represents a request to list the configuration sets associated with your Amazon Web Services account.
* Configuration sets enable you to publish email sending events. For information about using configuration
* sets, see the Amazon SES
* Developer Guide.
* @return Result of the ListConfigurationSets operation returned by the service.
* @sample AmazonSimpleEmailService.ListConfigurationSets
* @see AWS
* API Documentation
*/
@Override
public ListConfigurationSetsResult listConfigurationSets(ListConfigurationSetsRequest request) {
request = beforeClientExecution(request);
return executeListConfigurationSets(request);
}
@SdkInternalApi
final ListConfigurationSetsResult executeListConfigurationSets(ListConfigurationSetsRequest listConfigurationSetsRequest) {
ExecutionContext executionContext = createExecutionContext(listConfigurationSetsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListConfigurationSetsRequestMarshaller().marshall(super.beforeMarshalling(listConfigurationSetsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListConfigurationSets");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListConfigurationSetsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the existing custom verification email templates for your account in the current Amazon Web Services
* Region.
*
*
* For more information about custom verification email templates, see Using
* Custom Verification Email Templates in the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param listCustomVerificationEmailTemplatesRequest
* Represents a request to list the existing custom verification email templates for your account.
*
* For more information about custom verification email templates, see Using Custom Verification Email Templates in the Amazon SES Developer Guide.
* @return Result of the ListCustomVerificationEmailTemplates operation returned by the service.
* @sample AmazonSimpleEmailService.ListCustomVerificationEmailTemplates
* @see AWS API Documentation
*/
@Override
public ListCustomVerificationEmailTemplatesResult listCustomVerificationEmailTemplates(ListCustomVerificationEmailTemplatesRequest request) {
request = beforeClientExecution(request);
return executeListCustomVerificationEmailTemplates(request);
}
@SdkInternalApi
final ListCustomVerificationEmailTemplatesResult executeListCustomVerificationEmailTemplates(
ListCustomVerificationEmailTemplatesRequest listCustomVerificationEmailTemplatesRequest) {
ExecutionContext executionContext = createExecutionContext(listCustomVerificationEmailTemplatesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListCustomVerificationEmailTemplatesRequestMarshaller().marshall(super
.beforeMarshalling(listCustomVerificationEmailTemplatesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListCustomVerificationEmailTemplates");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListCustomVerificationEmailTemplatesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list containing all of the identities (email addresses and domains) for your Amazon Web Services
* account in the current Amazon Web Services Region, regardless of verification status.
*
*
* You can execute this operation no more than once per second.
*
*
*
* It's recommended that for successive pagination calls of this API, you continue to the use the same
* parameter/value pairs as used in the original call, e.g., if you used IdentityType=Domain in the the
* original call and received a NextToken in the response, you should continue providing the
* IdentityType=Domain parameter for further NextToken calls; however, if you didn't
* provide the IdentityType parameter in the original call, then continue to not provide it for
* successive pagination calls. Using this protocol will ensure consistent results.
*
*
*
* @param listIdentitiesRequest
* Represents a request to return a list of all identities (email addresses and domains) that you have
* attempted to verify under your Amazon Web Services account, regardless of verification status.
* @return Result of the ListIdentities operation returned by the service.
* @sample AmazonSimpleEmailService.ListIdentities
* @see AWS API
* Documentation
*/
@Override
public ListIdentitiesResult listIdentities(ListIdentitiesRequest request) {
request = beforeClientExecution(request);
return executeListIdentities(request);
}
@SdkInternalApi
final ListIdentitiesResult executeListIdentities(ListIdentitiesRequest listIdentitiesRequest) {
ExecutionContext executionContext = createExecutionContext(listIdentitiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListIdentitiesRequestMarshaller().marshall(super.beforeMarshalling(listIdentitiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListIdentities");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListIdentitiesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListIdentitiesResult listIdentities() {
return listIdentities(new ListIdentitiesRequest());
}
/**
*
* Returns a list of sending authorization policies that are attached to the given identity (an email address or a
* domain). This operation returns only a list. To get the actual policy content, use
* GetIdentityPolicies.
*
*
*
* This operation is for the identity owner only. If you have not verified the identity, it returns 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param listIdentityPoliciesRequest
* Represents a request to return a list of sending authorization policies that are attached to an identity.
* Sending authorization is an Amazon SES feature that enables you to authorize other senders to use your
* identities. For information, see the Amazon SES Developer
* Guide.
* @return Result of the ListIdentityPolicies operation returned by the service.
* @sample AmazonSimpleEmailService.ListIdentityPolicies
* @see AWS API
* Documentation
*/
@Override
public ListIdentityPoliciesResult listIdentityPolicies(ListIdentityPoliciesRequest request) {
request = beforeClientExecution(request);
return executeListIdentityPolicies(request);
}
@SdkInternalApi
final ListIdentityPoliciesResult executeListIdentityPolicies(ListIdentityPoliciesRequest listIdentityPoliciesRequest) {
ExecutionContext executionContext = createExecutionContext(listIdentityPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListIdentityPoliciesRequestMarshaller().marshall(super.beforeMarshalling(listIdentityPoliciesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListIdentityPolicies");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListIdentityPoliciesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the IP address filters associated with your Amazon Web Services account in the current Amazon Web Services
* Region.
*
*
* For information about managing IP address filters, see the Amazon SES
* Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param listReceiptFiltersRequest
* Represents a request to list the IP address filters that exist under your Amazon Web Services account. You
* use IP address filters when you receive email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the ListReceiptFilters operation returned by the service.
* @sample AmazonSimpleEmailService.ListReceiptFilters
* @see AWS API
* Documentation
*/
@Override
public ListReceiptFiltersResult listReceiptFilters(ListReceiptFiltersRequest request) {
request = beforeClientExecution(request);
return executeListReceiptFilters(request);
}
@SdkInternalApi
final ListReceiptFiltersResult executeListReceiptFilters(ListReceiptFiltersRequest listReceiptFiltersRequest) {
ExecutionContext executionContext = createExecutionContext(listReceiptFiltersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListReceiptFiltersRequestMarshaller().marshall(super.beforeMarshalling(listReceiptFiltersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListReceiptFilters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListReceiptFiltersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the receipt rule sets that exist under your Amazon Web Services account in the current Amazon Web Services
* Region. If there are additional receipt rule sets to be retrieved, you 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param listReceiptRuleSetsRequest
* Represents a request to list the receipt rule sets that exist under your Amazon Web Services account. You
* use receipt rule sets to receive email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the ListReceiptRuleSets operation returned by the service.
* @sample AmazonSimpleEmailService.ListReceiptRuleSets
* @see AWS API
* Documentation
*/
@Override
public ListReceiptRuleSetsResult listReceiptRuleSets(ListReceiptRuleSetsRequest request) {
request = beforeClientExecution(request);
return executeListReceiptRuleSets(request);
}
@SdkInternalApi
final ListReceiptRuleSetsResult executeListReceiptRuleSets(ListReceiptRuleSetsRequest listReceiptRuleSetsRequest) {
ExecutionContext executionContext = createExecutionContext(listReceiptRuleSetsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListReceiptRuleSetsRequestMarshaller().marshall(super.beforeMarshalling(listReceiptRuleSetsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListReceiptRuleSets");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListReceiptRuleSetsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the email templates present in your Amazon SES account in the current Amazon Web Services Region.
*
*
* You can execute this operation no more than once per second.
*
*
* @param listTemplatesRequest
* @return Result of the ListTemplates operation returned by the service.
* @sample AmazonSimpleEmailService.ListTemplates
* @see AWS API
* Documentation
*/
@Override
public ListTemplatesResult listTemplates(ListTemplatesRequest request) {
request = beforeClientExecution(request);
return executeListTemplates(request);
}
@SdkInternalApi
final ListTemplatesResult executeListTemplates(ListTemplatesRequest listTemplatesRequest) {
ExecutionContext executionContext = createExecutionContext(listTemplatesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTemplatesRequestMarshaller().marshall(super.beforeMarshalling(listTemplatesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTemplates");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ListTemplatesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deprecated. Use the ListIdentities operation to list the email addresses and domains associated with
* your account.
*
*
* @param listVerifiedEmailAddressesRequest
* @return Result of the ListVerifiedEmailAddresses operation returned by the service.
* @sample AmazonSimpleEmailService.ListVerifiedEmailAddresses
* @see AWS API Documentation
*/
@Override
public ListVerifiedEmailAddressesResult listVerifiedEmailAddresses(ListVerifiedEmailAddressesRequest request) {
request = beforeClientExecution(request);
return executeListVerifiedEmailAddresses(request);
}
@SdkInternalApi
final ListVerifiedEmailAddressesResult executeListVerifiedEmailAddresses(ListVerifiedEmailAddressesRequest listVerifiedEmailAddressesRequest) {
ExecutionContext executionContext = createExecutionContext(listVerifiedEmailAddressesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListVerifiedEmailAddressesRequestMarshaller().marshall(super.beforeMarshalling(listVerifiedEmailAddressesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListVerifiedEmailAddresses");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListVerifiedEmailAddressesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListVerifiedEmailAddressesResult listVerifiedEmailAddresses() {
return listVerifiedEmailAddresses(new ListVerifiedEmailAddressesRequest());
}
/**
*
* Adds or updates the delivery options for a configuration set.
*
*
* @param putConfigurationSetDeliveryOptionsRequest
* A request to modify the delivery options for a configuration set.
* @return Result of the PutConfigurationSetDeliveryOptions operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws InvalidDeliveryOptionsException
* Indicates that provided delivery option is invalid.
* @sample AmazonSimpleEmailService.PutConfigurationSetDeliveryOptions
* @see AWS API Documentation
*/
@Override
public PutConfigurationSetDeliveryOptionsResult putConfigurationSetDeliveryOptions(PutConfigurationSetDeliveryOptionsRequest request) {
request = beforeClientExecution(request);
return executePutConfigurationSetDeliveryOptions(request);
}
@SdkInternalApi
final PutConfigurationSetDeliveryOptionsResult executePutConfigurationSetDeliveryOptions(
PutConfigurationSetDeliveryOptionsRequest putConfigurationSetDeliveryOptionsRequest) {
ExecutionContext executionContext = createExecutionContext(putConfigurationSetDeliveryOptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutConfigurationSetDeliveryOptionsRequestMarshaller()
.marshall(super.beforeMarshalling(putConfigurationSetDeliveryOptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutConfigurationSetDeliveryOptions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new PutConfigurationSetDeliveryOptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds or updates a sending authorization policy for the specified identity (an email address or a domain).
*
*
*
* This operation is for the identity owner only. If you have not verified the identity, it returns 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param putIdentityPolicyRequest
* Represents a request to add or update a sending authorization policy for an identity. Sending
* authorization is an Amazon SES feature that enables you to authorize other senders to use your identities.
* For information, see the Amazon SES Developer
* Guide.
* @return Result of the PutIdentityPolicy operation returned by the service.
* @throws InvalidPolicyException
* Indicates that the provided policy is invalid. Check the error stack for more information about what
* caused the error.
* @sample AmazonSimpleEmailService.PutIdentityPolicy
* @see AWS API
* Documentation
*/
@Override
public PutIdentityPolicyResult putIdentityPolicy(PutIdentityPolicyRequest request) {
request = beforeClientExecution(request);
return executePutIdentityPolicy(request);
}
@SdkInternalApi
final PutIdentityPolicyResult executePutIdentityPolicy(PutIdentityPolicyRequest putIdentityPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(putIdentityPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutIdentityPolicyRequestMarshaller().marshall(super.beforeMarshalling(putIdentityPolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutIdentityPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new PutIdentityPolicyResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Reorders the receipt rules within a receipt rule set.
*
*
*
* All of the rules in the rule set must be represented in this request. That is, it is 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param reorderReceiptRuleSetRequest
* Represents a request to reorder the receipt rules within a receipt rule set. You use receipt rule sets to
* receive email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the ReorderReceiptRuleSet operation returned by the service.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @throws RuleDoesNotExistException
* Indicates that the provided receipt rule does not exist.
* @sample AmazonSimpleEmailService.ReorderReceiptRuleSet
* @see AWS
* API Documentation
*/
@Override
public ReorderReceiptRuleSetResult reorderReceiptRuleSet(ReorderReceiptRuleSetRequest request) {
request = beforeClientExecution(request);
return executeReorderReceiptRuleSet(request);
}
@SdkInternalApi
final ReorderReceiptRuleSetResult executeReorderReceiptRuleSet(ReorderReceiptRuleSetRequest reorderReceiptRuleSetRequest) {
ExecutionContext executionContext = createExecutionContext(reorderReceiptRuleSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ReorderReceiptRuleSetRequestMarshaller().marshall(super.beforeMarshalling(reorderReceiptRuleSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ReorderReceiptRuleSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ReorderReceiptRuleSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Generates and sends a bounce message to the sender of an email you received through Amazon SES. You can only use
* this operation on an email up to 24 hours after you receive it.
*
*
*
* You cannot use this operation 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param sendBounceRequest
* Represents a request to send a bounce message to the sender of an email you received through Amazon SES.
* @return Result of the SendBounce operation returned by the service.
* @throws MessageRejectedException
* Indicates that the action failed, and the message could not be sent. Check the error stack for more
* information about what caused the error.
* @sample AmazonSimpleEmailService.SendBounce
* @see AWS API
* Documentation
*/
@Override
public SendBounceResult sendBounce(SendBounceRequest request) {
request = beforeClientExecution(request);
return executeSendBounce(request);
}
@SdkInternalApi
final SendBounceResult executeSendBounce(SendBounceRequest sendBounceRequest) {
ExecutionContext executionContext = createExecutionContext(sendBounceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SendBounceRequestMarshaller().marshall(super.beforeMarshalling(sendBounceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SendBounce");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new SendBounceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Composes an email message to multiple destinations. The message body is created using an email template.
*
*
* To send email using this operation, your call must meet the following requirements:
*
*
* -
*
* The call must refer to an existing email template. You can create email templates using CreateTemplate.
*
*
* -
*
* The message must be sent from a verified email address or domain.
*
*
* -
*
* If your account is still in the Amazon SES sandbox, you may send only to verified addresses or domains, or to
* email addresses associated with the Amazon SES Mailbox Simulator. For more information, see Verifying Email Addresses and
* Domains in the Amazon SES Developer Guide.
*
*
* -
*
* The maximum message size is 10 MB.
*
*
* -
*
* Each Destination parameter must include at least one recipient email address. The recipient address
* can be a To: address, a CC: address, or a BCC: address. If a recipient email address is invalid (that is, it is
* not in the format UserName@[SubDomain.]Domain.TopLevelDomain), the entire message is rejected, even if the
* message contains other recipients that are valid.
*
*
* -
*
* The message may not include more than 50 recipients, across the To:, CC: and BCC: fields. 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
* the SendBulkTemplatedEmail operation several times to send the message to each group.
*
*
* -
*
* The number of destinations you can contact in a single call can be limited by your account's maximum sending
* rate.
*
*
*
*
* @param sendBulkTemplatedEmailRequest
* Represents a request to send a templated email to multiple destinations using Amazon SES. For more
* information, see the Amazon SES Developer
* Guide.
* @return Result of the SendBulkTemplatedEmail operation returned by the service.
* @throws MessageRejectedException
* Indicates that the action failed, and the message could not be sent. Check the error stack for more
* information about what caused the error.
* @throws MailFromDomainNotVerifiedException
* Indicates that the message could not be sent because Amazon SES could not read the MX record required to
* use the specified MAIL FROM domain. For information about editing the custom MAIL FROM domain settings
* for an identity, see the Amazon SES Developer
* Guide.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws TemplateDoesNotExistException
* Indicates that the Template object you specified does not exist in your Amazon SES account.
* @throws ConfigurationSetSendingPausedException
* Indicates that email sending is disabled for the configuration set.
*
* You can enable or disable email sending for a configuration set using
* UpdateConfigurationSetSendingEnabled.
* @throws AccountSendingPausedException
* Indicates that email sending is disabled for your entire Amazon SES account.
*
*
* You can enable or disable email sending for your Amazon SES account using
* UpdateAccountSendingEnabled.
* @sample AmazonSimpleEmailService.SendBulkTemplatedEmail
* @see AWS
* API Documentation
*/
@Override
public SendBulkTemplatedEmailResult sendBulkTemplatedEmail(SendBulkTemplatedEmailRequest request) {
request = beforeClientExecution(request);
return executeSendBulkTemplatedEmail(request);
}
@SdkInternalApi
final SendBulkTemplatedEmailResult executeSendBulkTemplatedEmail(SendBulkTemplatedEmailRequest sendBulkTemplatedEmailRequest) {
ExecutionContext executionContext = createExecutionContext(sendBulkTemplatedEmailRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SendBulkTemplatedEmailRequestMarshaller().marshall(super.beforeMarshalling(sendBulkTemplatedEmailRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SendBulkTemplatedEmail");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SendBulkTemplatedEmailResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds an email address to the list of identities for your Amazon SES account in the current Amazon Web Services
* Region and attempts to verify it. As a result of executing this operation, a customized verification email is
* sent to the specified address.
*
*
* To use this operation, you must first create a custom verification email template. For more information about
* creating and using custom verification email templates, see Using
* Custom Verification Email Templates in the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param sendCustomVerificationEmailRequest
* Represents a request to send a custom verification email to a specified recipient.
* @return Result of the SendCustomVerificationEmail operation returned by the service.
* @throws MessageRejectedException
* Indicates that the action failed, and the message could not be sent. Check the error stack for more
* information about what caused the error.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws CustomVerificationEmailTemplateDoesNotExistException
* Indicates that a custom verification email template with the name you specified does not exist.
* @throws FromEmailAddressNotVerifiedException
* Indicates that the sender address specified for a custom verification email is not verified, and is
* therefore not eligible to send the custom verification email.
* @throws ProductionAccessNotGrantedException
* Indicates that the account has not been granted production access.
* @sample AmazonSimpleEmailService.SendCustomVerificationEmail
* @see AWS API Documentation
*/
@Override
public SendCustomVerificationEmailResult sendCustomVerificationEmail(SendCustomVerificationEmailRequest request) {
request = beforeClientExecution(request);
return executeSendCustomVerificationEmail(request);
}
@SdkInternalApi
final SendCustomVerificationEmailResult executeSendCustomVerificationEmail(SendCustomVerificationEmailRequest sendCustomVerificationEmailRequest) {
ExecutionContext executionContext = createExecutionContext(sendCustomVerificationEmailRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SendCustomVerificationEmailRequestMarshaller().marshall(super.beforeMarshalling(sendCustomVerificationEmailRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SendCustomVerificationEmail");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SendCustomVerificationEmailResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Composes an email message and immediately queues it for sending. To send email using this operation, your message
* must meet the following requirements:
*
*
* -
*
* The message must be sent from a verified email address or domain. If you attempt to send email using a
* non-verified address or domain, the operation results in an "Email address not verified" error.
*
*
* -
*
* If your account is still in the Amazon SES sandbox, you may only send to verified addresses or domains, or to
* email addresses associated with the Amazon SES Mailbox Simulator. For more information, see Verifying Email Addresses and
* Domains in the Amazon SES Developer Guide.
*
*
* -
*
* The maximum message size is 10 MB.
*
*
* -
*
* The message must include at least one recipient email address. The recipient address can be a To: address, a CC:
* address, or a BCC: address. If a recipient email address is invalid (that is, it is not in the format
* UserName@[SubDomain.]Domain.TopLevelDomain), the entire message is rejected, even if the message contains
* other recipients that are valid.
*
*
* -
*
* The message may not include more than 50 recipients, across the To:, CC: and BCC: fields. 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
* the SendEmail operation several times to send the message to each group.
*
*
*
*
*
* For every message that you send, the total number of recipients (including each recipient in the To:, CC: and
* BCC: fields) is counted against the maximum number of emails you can send in a 24-hour period (your sending
* quota). For more information about sending quotas in Amazon SES, see Managing Your Amazon SES Sending
* Limits in the Amazon SES Developer Guide.
*
*
*
* @param sendEmailRequest
* Represents a request to send a single formatted email using Amazon SES. For more information, see the Amazon SES Developer Guide.
* @return Result of the SendEmail operation returned by the service.
* @throws MessageRejectedException
* Indicates that the action failed, and the message could not be sent. Check the error stack for more
* information about what caused the error.
* @throws MailFromDomainNotVerifiedException
* Indicates that the message could not be sent because Amazon SES could not read the MX record required to
* use the specified MAIL FROM domain. For information about editing the custom MAIL FROM domain settings
* for an identity, see the Amazon SES Developer
* Guide.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws ConfigurationSetSendingPausedException
* Indicates that email sending is disabled for the configuration set.
*
* You can enable or disable email sending for a configuration set using
* UpdateConfigurationSetSendingEnabled.
* @throws AccountSendingPausedException
* Indicates that email sending is disabled for your entire Amazon SES account.
*
*
* You can enable or disable email sending for your Amazon SES account using
* UpdateAccountSendingEnabled.
* @sample AmazonSimpleEmailService.SendEmail
* @see AWS API
* Documentation
*/
@Override
public SendEmailResult sendEmail(SendEmailRequest request) {
request = beforeClientExecution(request);
return executeSendEmail(request);
}
@SdkInternalApi
final SendEmailResult executeSendEmail(SendEmailRequest sendEmailRequest) {
ExecutionContext executionContext = createExecutionContext(sendEmailRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SendEmailRequestMarshaller().marshall(super.beforeMarshalling(sendEmailRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SendEmail");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new SendEmailResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Composes an email message and immediately queues it for sending.
*
*
* This operation is more flexible than the SendEmail operation. When you use the
* SendRawEmail operation, you can specify the headers of the message as well as its content. This
* flexibility is useful, for example, when you need to send a multipart MIME email (such a message that contains
* both a text and an HTML version). You can also use this operation to send messages that include attachments.
*
*
* The SendRawEmail operation has the following requirements:
*
*
* -
*
* You can only send email from verified email addresses or
* domains. If you try to send email from an address that isn't verified, the operation results in an
* "Email address not verified" error.
*
*
* -
*
* If your account is still in the Amazon SES sandbox, you can
* only send email to other verified addresses in your account, or to addresses that are associated with the Amazon SES mailbox
* simulator.
*
*
* -
*
* The maximum message size, including attachments, is 10 MB.
*
*
* -
*
* Each message has to include at least one recipient address. A recipient address includes any address on the To:,
* CC:, or BCC: lines.
*
*
* -
*
* If you send a single message to more than one recipient address, and one of the recipient addresses isn't in a
* valid format (that is, it's not in the format UserName@[SubDomain.]Domain.TopLevelDomain), Amazon SES
* rejects the entire message, even if the other addresses are valid.
*
*
* -
*
* Each message can include up to 50 recipient addresses across the To:, CC:, or BCC: lines. If you need to send a
* single message to more than 50 recipients, you have to split the list of recipient addresses into groups of less
* than 50 recipients, and send separate messages to each group.
*
*
* -
*
* Amazon SES allows you to specify 8-bit Content-Transfer-Encoding for MIME message parts. However, if Amazon SES
* has to modify the contents of your message (for example, if you use open and click tracking), 8-bit content isn't
* preserved. For this reason, we highly recommend that you encode all content that isn't 7-bit ASCII. For more
* information, see MIME Encoding
* in the Amazon SES Developer Guide.
*
*
*
*
* Additionally, keep the following considerations in mind when using the SendRawEmail operation:
*
*
* -
*
* Although you can customize the message headers when using the SendRawEmail operation, Amazon SES
* automatically applies its own Message-ID and Date headers; if you passed these headers
* when creating the message, they are overwritten by the values that Amazon SES provides.
*
*
* -
*
* 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, 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
*
*
*
*
*
* Don't include these X-headers in the DKIM signature. Amazon SES removes these before it sends the email.
*
*
*
* If you only specify the SourceIdentityArn parameter, Amazon SES sets the From and Return-Path
* addresses to the same identity that you specified.
*
*
* For more information about sending authorization, see the Using Sending Authorization with
* Amazon SES in the Amazon SES Developer Guide.
*
*
* -
*
* For every message that you send, the total number of recipients (including each recipient in the To:, CC: and
* BCC: fields) is counted against the maximum number of emails you can send in a 24-hour period (your sending
* quota). For more information about sending quotas in Amazon SES, see Managing Your Amazon SES Sending
* Limits in the Amazon SES Developer Guide.
*
*
*
*
* @param sendRawEmailRequest
* Represents a request to send a single raw email using Amazon SES. For more information, see the Amazon SES Developer Guide.
* @return Result of the SendRawEmail operation returned by the service.
* @throws MessageRejectedException
* Indicates that the action failed, and the message could not be sent. Check the error stack for more
* information about what caused the error.
* @throws MailFromDomainNotVerifiedException
* Indicates that the message could not be sent because Amazon SES could not read the MX record required to
* use the specified MAIL FROM domain. For information about editing the custom MAIL FROM domain settings
* for an identity, see the Amazon SES Developer
* Guide.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws ConfigurationSetSendingPausedException
* Indicates that email sending is disabled for the configuration set.
*
* You can enable or disable email sending for a configuration set using
* UpdateConfigurationSetSendingEnabled.
* @throws AccountSendingPausedException
* Indicates that email sending is disabled for your entire Amazon SES account.
*
*
* You can enable or disable email sending for your Amazon SES account using
* UpdateAccountSendingEnabled.
* @sample AmazonSimpleEmailService.SendRawEmail
* @see AWS API
* Documentation
*/
@Override
public SendRawEmailResult sendRawEmail(SendRawEmailRequest request) {
request = beforeClientExecution(request);
return executeSendRawEmail(request);
}
@SdkInternalApi
final SendRawEmailResult executeSendRawEmail(SendRawEmailRequest sendRawEmailRequest) {
ExecutionContext executionContext = createExecutionContext(sendRawEmailRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SendRawEmailRequestMarshaller().marshall(super.beforeMarshalling(sendRawEmailRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SendRawEmail");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new SendRawEmailResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Composes an email message using an email template and immediately queues it for sending.
*
*
* To send email using this operation, your call must meet the following requirements:
*
*
* -
*
* The call must refer to an existing email template. You can create email templates using the CreateTemplate
* operation.
*
*
* -
*
* The message must be sent from a verified email address or domain.
*
*
* -
*
* If your account is still in the Amazon SES sandbox, you may only send to verified addresses or domains, or to
* email addresses associated with the Amazon SES Mailbox Simulator. For more information, see Verifying Email Addresses and
* Domains in the Amazon SES Developer Guide.
*
*
* -
*
* The maximum message size is 10 MB.
*
*
* -
*
* Calls to the SendTemplatedEmail operation may only include one Destination parameter. A
* destination is a set of recipients that receives the same version of the email. The Destination
* parameter can include up to 50 recipients, across the To:, CC: and BCC: fields.
*
*
* -
*
* The Destination parameter must include at least one recipient email address. The recipient address
* can be a To: address, a CC: address, or a BCC: address. If a recipient email address is invalid (that is, it is
* not in the format UserName@[SubDomain.]Domain.TopLevelDomain), the entire message is rejected, even if the
* message contains other recipients that are valid.
*
*
*
*
*
* If your call to the SendTemplatedEmail operation includes all of the required parameters, Amazon SES
* accepts it and returns a Message ID. However, if Amazon SES can't render the email because the template contains
* errors, it doesn't send the email. Additionally, because it already accepted the message, Amazon SES doesn't
* return a message stating that it was unable to send the email.
*
*
* For these reasons, we highly recommend that you set up Amazon SES to send you notifications when Rendering
* Failure events occur. For more information, see Sending Personalized Email
* Using the Amazon SES API in the Amazon Simple Email Service Developer Guide.
*
*
*
* @param sendTemplatedEmailRequest
* Represents a request to send a templated email using Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the SendTemplatedEmail operation returned by the service.
* @throws MessageRejectedException
* Indicates that the action failed, and the message could not be sent. Check the error stack for more
* information about what caused the error.
* @throws MailFromDomainNotVerifiedException
* Indicates that the message could not be sent because Amazon SES could not read the MX record required to
* use the specified MAIL FROM domain. For information about editing the custom MAIL FROM domain settings
* for an identity, see the Amazon SES Developer
* Guide.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws TemplateDoesNotExistException
* Indicates that the Template object you specified does not exist in your Amazon SES account.
* @throws ConfigurationSetSendingPausedException
* Indicates that email sending is disabled for the configuration set.
*
* You can enable or disable email sending for a configuration set using
* UpdateConfigurationSetSendingEnabled.
* @throws AccountSendingPausedException
* Indicates that email sending is disabled for your entire Amazon SES account.
*
*
* You can enable or disable email sending for your Amazon SES account using
* UpdateAccountSendingEnabled.
* @sample AmazonSimpleEmailService.SendTemplatedEmail
* @see AWS API
* Documentation
*/
@Override
public SendTemplatedEmailResult sendTemplatedEmail(SendTemplatedEmailRequest request) {
request = beforeClientExecution(request);
return executeSendTemplatedEmail(request);
}
@SdkInternalApi
final SendTemplatedEmailResult executeSendTemplatedEmail(SendTemplatedEmailRequest sendTemplatedEmailRequest) {
ExecutionContext executionContext = createExecutionContext(sendTemplatedEmailRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SendTemplatedEmailRequestMarshaller().marshall(super.beforeMarshalling(sendTemplatedEmailRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SendTemplatedEmail");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SendTemplatedEmailResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets the specified receipt rule set as the active receipt rule set.
*
*
*
* To disable your email-receiving through Amazon SES completely, you can call this operation with
* RuleSetName set to null.
*
*
*
* For information about managing receipt rule sets, see the Amazon
* SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param setActiveReceiptRuleSetRequest
* Represents a request to set a receipt rule set as the active receipt rule set. You use receipt rule sets
* to receive email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the SetActiveReceiptRuleSet operation returned by the service.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @sample AmazonSimpleEmailService.SetActiveReceiptRuleSet
* @see AWS
* API Documentation
*/
@Override
public SetActiveReceiptRuleSetResult setActiveReceiptRuleSet(SetActiveReceiptRuleSetRequest request) {
request = beforeClientExecution(request);
return executeSetActiveReceiptRuleSet(request);
}
@SdkInternalApi
final SetActiveReceiptRuleSetResult executeSetActiveReceiptRuleSet(SetActiveReceiptRuleSetRequest setActiveReceiptRuleSetRequest) {
ExecutionContext executionContext = createExecutionContext(setActiveReceiptRuleSetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetActiveReceiptRuleSetRequestMarshaller().marshall(super.beforeMarshalling(setActiveReceiptRuleSetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetActiveReceiptRuleSet");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SetActiveReceiptRuleSetResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Enables or disables Easy DKIM signing of email sent from an identity. If Easy DKIM signing is enabled for a
* domain, then Amazon SES uses DKIM to sign all email that it sends from addresses on that domain. If Easy DKIM
* signing is enabled for an email address, then Amazon SES uses DKIM to sign all email it sends from that address.
*
*
*
* For email addresses (for example, [email protected]), you can only enable DKIM signing if the
* corresponding domain (in this case, example.com) has been set up to use Easy DKIM.
*
*
*
* You can enable DKIM signing for an identity at any time after you start the verification process for the
* identity, even if the verification process isn't complete.
*
*
* You can execute this operation no more than once per second.
*
*
* For more information about Easy DKIM signing, go to the Amazon SES Developer
* Guide.
*
*
* @param setIdentityDkimEnabledRequest
* Represents a request to enable or disable Amazon SES Easy DKIM signing for an identity. For more
* information about setting up Easy DKIM, see the Amazon SES
* Developer Guide.
* @return Result of the SetIdentityDkimEnabled operation returned by the service.
* @sample AmazonSimpleEmailService.SetIdentityDkimEnabled
* @see AWS
* API Documentation
*/
@Override
public SetIdentityDkimEnabledResult setIdentityDkimEnabled(SetIdentityDkimEnabledRequest request) {
request = beforeClientExecution(request);
return executeSetIdentityDkimEnabled(request);
}
@SdkInternalApi
final SetIdentityDkimEnabledResult executeSetIdentityDkimEnabled(SetIdentityDkimEnabledRequest setIdentityDkimEnabledRequest) {
ExecutionContext executionContext = createExecutionContext(setIdentityDkimEnabledRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetIdentityDkimEnabledRequestMarshaller().marshall(super.beforeMarshalling(setIdentityDkimEnabledRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetIdentityDkimEnabled");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SetIdentityDkimEnabledResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Given an identity (an email address or a 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.
*
*
*
* Feedback forwarding does not apply to delivery notifications. Delivery notifications are only available through
* Amazon SNS.
*
*
*
* You can execute this operation no more than once per second.
*
*
* For more information about using notifications with Amazon SES, see the Amazon SES
* Developer Guide.
*
*
* @param setIdentityFeedbackForwardingEnabledRequest
* Represents a request to enable or disable whether Amazon SES forwards you bounce and complaint
* notifications through email. For information about email feedback forwarding, see the Amazon SES Developer Guide.
* @return Result of the SetIdentityFeedbackForwardingEnabled operation returned by the service.
* @sample AmazonSimpleEmailService.SetIdentityFeedbackForwardingEnabled
* @see AWS API Documentation
*/
@Override
public SetIdentityFeedbackForwardingEnabledResult setIdentityFeedbackForwardingEnabled(SetIdentityFeedbackForwardingEnabledRequest request) {
request = beforeClientExecution(request);
return executeSetIdentityFeedbackForwardingEnabled(request);
}
@SdkInternalApi
final SetIdentityFeedbackForwardingEnabledResult executeSetIdentityFeedbackForwardingEnabled(
SetIdentityFeedbackForwardingEnabledRequest setIdentityFeedbackForwardingEnabledRequest) {
ExecutionContext executionContext = createExecutionContext(setIdentityFeedbackForwardingEnabledRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetIdentityFeedbackForwardingEnabledRequestMarshaller().marshall(super
.beforeMarshalling(setIdentityFeedbackForwardingEnabledRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetIdentityFeedbackForwardingEnabled");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SetIdentityFeedbackForwardingEnabledResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Given an identity (an email address or a domain), sets whether Amazon SES includes the original email headers in
* the Amazon Simple Notification Service (Amazon SNS) notifications of a specified type.
*
*
* You can execute this operation no more than once per second.
*
*
* For more information about using notifications with Amazon SES, see the Amazon SES
* Developer Guide.
*
*
* @param setIdentityHeadersInNotificationsEnabledRequest
* Represents a request to set whether Amazon SES includes the original email headers in the Amazon SNS
* notifications of a specified type. For information about notifications, see the Amazon SES Developer Guide.
* @return Result of the SetIdentityHeadersInNotificationsEnabled operation returned by the service.
* @sample AmazonSimpleEmailService.SetIdentityHeadersInNotificationsEnabled
* @see AWS API Documentation
*/
@Override
public SetIdentityHeadersInNotificationsEnabledResult setIdentityHeadersInNotificationsEnabled(SetIdentityHeadersInNotificationsEnabledRequest request) {
request = beforeClientExecution(request);
return executeSetIdentityHeadersInNotificationsEnabled(request);
}
@SdkInternalApi
final SetIdentityHeadersInNotificationsEnabledResult executeSetIdentityHeadersInNotificationsEnabled(
SetIdentityHeadersInNotificationsEnabledRequest setIdentityHeadersInNotificationsEnabledRequest) {
ExecutionContext executionContext = createExecutionContext(setIdentityHeadersInNotificationsEnabledRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetIdentityHeadersInNotificationsEnabledRequestMarshaller().marshall(super
.beforeMarshalling(setIdentityHeadersInNotificationsEnabledRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetIdentityHeadersInNotificationsEnabled");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SetIdentityHeadersInNotificationsEnabledResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Enables or disables the custom MAIL FROM domain setup for a verified identity (an email address or a domain).
*
*
*
* To send emails using the specified MAIL FROM domain, you must add an MX record to your MAIL FROM domain's DNS
* settings. To ensure that your emails pass Sender Policy Framework (SPF) checks, you must also add or update an
* SPF record. For more information, see the Amazon SES Developer Guide.
*
*
*
* You can execute this operation no more than once per second.
*
*
* @param setIdentityMailFromDomainRequest
* Represents a request to enable or disable the Amazon SES custom MAIL FROM domain setup for a verified
* identity. For information about using a custom MAIL FROM domain, see the Amazon SES Developer Guide.
* @return Result of the SetIdentityMailFromDomain operation returned by the service.
* @sample AmazonSimpleEmailService.SetIdentityMailFromDomain
* @see AWS API Documentation
*/
@Override
public SetIdentityMailFromDomainResult setIdentityMailFromDomain(SetIdentityMailFromDomainRequest request) {
request = beforeClientExecution(request);
return executeSetIdentityMailFromDomain(request);
}
@SdkInternalApi
final SetIdentityMailFromDomainResult executeSetIdentityMailFromDomain(SetIdentityMailFromDomainRequest setIdentityMailFromDomainRequest) {
ExecutionContext executionContext = createExecutionContext(setIdentityMailFromDomainRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetIdentityMailFromDomainRequestMarshaller().marshall(super.beforeMarshalling(setIdentityMailFromDomainRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetIdentityMailFromDomain");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SetIdentityMailFromDomainResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets an Amazon Simple Notification Service (Amazon SNS) topic to use when delivering notifications. When you use
* this operation, you specify a verified identity, such as an email address or domain. When you send an email that
* uses the chosen identity in the Source field, Amazon SES sends notifications to the topic you specified. You can
* send bounce, complaint, or delivery notifications (or any combination of the three) to the Amazon SNS topic that
* you specify.
*
*
* You can execute this operation no more than once per second.
*
*
* For more information about feedback notification, see the Amazon SES
* Developer Guide.
*
*
* @param setIdentityNotificationTopicRequest
* Represents a request to specify the Amazon SNS topic to which Amazon SES publishes bounce, complaint, or
* delivery notifications for emails sent with that identity as the source. For information about Amazon SES
* notifications, see the Amazon SES Developer Guide.
* @return Result of the SetIdentityNotificationTopic operation returned by the service.
* @sample AmazonSimpleEmailService.SetIdentityNotificationTopic
* @see AWS API Documentation
*/
@Override
public SetIdentityNotificationTopicResult setIdentityNotificationTopic(SetIdentityNotificationTopicRequest request) {
request = beforeClientExecution(request);
return executeSetIdentityNotificationTopic(request);
}
@SdkInternalApi
final SetIdentityNotificationTopicResult executeSetIdentityNotificationTopic(SetIdentityNotificationTopicRequest setIdentityNotificationTopicRequest) {
ExecutionContext executionContext = createExecutionContext(setIdentityNotificationTopicRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetIdentityNotificationTopicRequestMarshaller().marshall(super.beforeMarshalling(setIdentityNotificationTopicRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetIdentityNotificationTopic");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SetIdentityNotificationTopicResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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.
*
*
* You can execute this operation no more than once per second.
*
*
* @param setReceiptRulePositionRequest
* Represents a request to set the position of a receipt rule in a receipt rule set. You use receipt rule
* sets to receive email with Amazon SES. For more information, see the Amazon SES Developer
* Guide.
* @return Result of the SetReceiptRulePosition operation returned by the service.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @throws RuleDoesNotExistException
* Indicates that the provided receipt rule does not exist.
* @sample AmazonSimpleEmailService.SetReceiptRulePosition
* @see AWS
* API Documentation
*/
@Override
public SetReceiptRulePositionResult setReceiptRulePosition(SetReceiptRulePositionRequest request) {
request = beforeClientExecution(request);
return executeSetReceiptRulePosition(request);
}
@SdkInternalApi
final SetReceiptRulePositionResult executeSetReceiptRulePosition(SetReceiptRulePositionRequest setReceiptRulePositionRequest) {
ExecutionContext executionContext = createExecutionContext(setReceiptRulePositionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetReceiptRulePositionRequestMarshaller().marshall(super.beforeMarshalling(setReceiptRulePositionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetReceiptRulePosition");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SetReceiptRulePositionResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a preview of the MIME content of an email when provided with a template and a set of replacement data.
*
*
* You can execute this operation no more than once per second.
*
*
* @param testRenderTemplateRequest
* @return Result of the TestRenderTemplate operation returned by the service.
* @throws TemplateDoesNotExistException
* Indicates that the Template object you specified does not exist in your Amazon SES account.
* @throws InvalidRenderingParameterException
* Indicates that one or more of the replacement values you provided is invalid. This error may occur when
* the TemplateData object contains invalid JSON.
* @throws MissingRenderingAttributeException
* Indicates that one or more of the replacement values for the specified template was not specified. Ensure
* that the TemplateData object contains references to all of the replacement tags in the specified
* template.
* @sample AmazonSimpleEmailService.TestRenderTemplate
* @see AWS API
* Documentation
*/
@Override
public TestRenderTemplateResult testRenderTemplate(TestRenderTemplateRequest request) {
request = beforeClientExecution(request);
return executeTestRenderTemplate(request);
}
@SdkInternalApi
final TestRenderTemplateResult executeTestRenderTemplate(TestRenderTemplateRequest testRenderTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(testRenderTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TestRenderTemplateRequestMarshaller().marshall(super.beforeMarshalling(testRenderTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TestRenderTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new TestRenderTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Enables or disables email sending across your entire Amazon SES account in the current Amazon Web Services
* Region. You can use this operation in conjunction with Amazon CloudWatch alarms to temporarily pause email
* sending across your Amazon SES account in a given Amazon Web Services Region when reputation metrics (such as
* your bounce or complaint rates) reach certain thresholds.
*
*
* You can execute this operation no more than once per second.
*
*
* @param updateAccountSendingEnabledRequest
* Represents a request to enable or disable the email sending capabilities for your entire Amazon SES
* account.
* @return Result of the UpdateAccountSendingEnabled operation returned by the service.
* @sample AmazonSimpleEmailService.UpdateAccountSendingEnabled
* @see AWS API Documentation
*/
@Override
public UpdateAccountSendingEnabledResult updateAccountSendingEnabled(UpdateAccountSendingEnabledRequest request) {
request = beforeClientExecution(request);
return executeUpdateAccountSendingEnabled(request);
}
@SdkInternalApi
final UpdateAccountSendingEnabledResult executeUpdateAccountSendingEnabled(UpdateAccountSendingEnabledRequest updateAccountSendingEnabledRequest) {
ExecutionContext executionContext = createExecutionContext(updateAccountSendingEnabledRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateAccountSendingEnabledRequestMarshaller().marshall(super.beforeMarshalling(updateAccountSendingEnabledRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateAccountSendingEnabled");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new UpdateAccountSendingEnabledResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the event destination of a configuration set. Event destinations are associated with configuration sets,
* which enable you to publish email sending events to Amazon CloudWatch, Amazon Kinesis Firehose, or Amazon Simple
* Notification Service (Amazon SNS). For information about using configuration sets, see Monitoring Your Amazon SES Sending
* Activity in the Amazon SES Developer Guide.
*
*
*
* When you create or update an event destination, you must provide one, and only one, destination. The destination
* can be Amazon CloudWatch, Amazon Kinesis Firehose, or Amazon Simple Notification Service (Amazon SNS).
*
*
*
* You can execute this operation no more than once per second.
*
*
* @param updateConfigurationSetEventDestinationRequest
* Represents a request to update the event destination of a configuration set. Configuration sets enable you
* to publish email sending events. For information about using configuration sets, see the Amazon SES Developer
* Guide.
* @return Result of the UpdateConfigurationSetEventDestination operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws EventDestinationDoesNotExistException
* Indicates that the event destination does not exist.
* @throws InvalidCloudWatchDestinationException
* Indicates that the Amazon CloudWatch destination is invalid. See the error message for details.
* @throws InvalidFirehoseDestinationException
* Indicates that the Amazon Kinesis Firehose destination is invalid. See the error message for details.
* @throws InvalidSNSDestinationException
* Indicates that the Amazon Simple Notification Service (Amazon SNS) destination is invalid. See the error
* message for details.
* @sample AmazonSimpleEmailService.UpdateConfigurationSetEventDestination
* @see AWS API Documentation
*/
@Override
public UpdateConfigurationSetEventDestinationResult updateConfigurationSetEventDestination(UpdateConfigurationSetEventDestinationRequest request) {
request = beforeClientExecution(request);
return executeUpdateConfigurationSetEventDestination(request);
}
@SdkInternalApi
final UpdateConfigurationSetEventDestinationResult executeUpdateConfigurationSetEventDestination(
UpdateConfigurationSetEventDestinationRequest updateConfigurationSetEventDestinationRequest) {
ExecutionContext executionContext = createExecutionContext(updateConfigurationSetEventDestinationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateConfigurationSetEventDestinationRequestMarshaller().marshall(super
.beforeMarshalling(updateConfigurationSetEventDestinationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateConfigurationSetEventDestination");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new UpdateConfigurationSetEventDestinationResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Enables or disables the publishing of reputation metrics for emails sent using a specific configuration set in a
* given Amazon Web Services Region. Reputation metrics include bounce and complaint rates. These metrics are
* published to Amazon CloudWatch. By using CloudWatch, you can create alarms when bounce or complaint rates exceed
* certain thresholds.
*
*
* You can execute this operation no more than once per second.
*
*
* @param updateConfigurationSetReputationMetricsEnabledRequest
* Represents a request to modify the reputation metric publishing settings for a configuration set.
* @return Result of the UpdateConfigurationSetReputationMetricsEnabled operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @sample AmazonSimpleEmailService.UpdateConfigurationSetReputationMetricsEnabled
* @see AWS API Documentation
*/
@Override
public UpdateConfigurationSetReputationMetricsEnabledResult updateConfigurationSetReputationMetricsEnabled(
UpdateConfigurationSetReputationMetricsEnabledRequest request) {
request = beforeClientExecution(request);
return executeUpdateConfigurationSetReputationMetricsEnabled(request);
}
@SdkInternalApi
final UpdateConfigurationSetReputationMetricsEnabledResult executeUpdateConfigurationSetReputationMetricsEnabled(
UpdateConfigurationSetReputationMetricsEnabledRequest updateConfigurationSetReputationMetricsEnabledRequest) {
ExecutionContext executionContext = createExecutionContext(updateConfigurationSetReputationMetricsEnabledRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateConfigurationSetReputationMetricsEnabledRequestMarshaller().marshall(super
.beforeMarshalling(updateConfigurationSetReputationMetricsEnabledRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateConfigurationSetReputationMetricsEnabled");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new UpdateConfigurationSetReputationMetricsEnabledResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Enables or disables email sending for messages sent using a specific configuration set in a given Amazon Web
* Services Region. You can use this operation in conjunction with Amazon CloudWatch alarms to temporarily pause
* email sending for a configuration set when the reputation metrics for that configuration set (such as your bounce
* on complaint rate) exceed certain thresholds.
*
*
* You can execute this operation no more than once per second.
*
*
* @param updateConfigurationSetSendingEnabledRequest
* Represents a request to enable or disable the email sending capabilities for a specific configuration set.
* @return Result of the UpdateConfigurationSetSendingEnabled operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @sample AmazonSimpleEmailService.UpdateConfigurationSetSendingEnabled
* @see AWS API Documentation
*/
@Override
public UpdateConfigurationSetSendingEnabledResult updateConfigurationSetSendingEnabled(UpdateConfigurationSetSendingEnabledRequest request) {
request = beforeClientExecution(request);
return executeUpdateConfigurationSetSendingEnabled(request);
}
@SdkInternalApi
final UpdateConfigurationSetSendingEnabledResult executeUpdateConfigurationSetSendingEnabled(
UpdateConfigurationSetSendingEnabledRequest updateConfigurationSetSendingEnabledRequest) {
ExecutionContext executionContext = createExecutionContext(updateConfigurationSetSendingEnabledRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateConfigurationSetSendingEnabledRequestMarshaller().marshall(super
.beforeMarshalling(updateConfigurationSetSendingEnabledRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateConfigurationSetSendingEnabled");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new UpdateConfigurationSetSendingEnabledResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies an association between a configuration set and a custom domain for open and click event tracking.
*
*
* By default, images and links used for tracking open and click events are hosted on domains operated by Amazon
* SES. You can configure a subdomain of your own to handle these events. For information about using custom
* domains, see the Amazon SES Developer
* Guide.
*
*
* @param updateConfigurationSetTrackingOptionsRequest
* Represents a request to update the tracking options for a configuration set.
* @return Result of the UpdateConfigurationSetTrackingOptions operation returned by the service.
* @throws ConfigurationSetDoesNotExistException
* Indicates that the configuration set does not exist.
* @throws TrackingOptionsDoesNotExistException
* Indicates that the TrackingOptions object you specified does not exist.
* @throws InvalidTrackingOptionsException
* Indicates that the custom domain to be used for open and click tracking redirects is invalid. This error
* appears most often in the following situations:
*
* -
*
* When the tracking domain you specified is not verified in Amazon SES.
*
*
* -
*
* When the tracking domain you specified is not a valid domain or subdomain.
*
*
* @sample AmazonSimpleEmailService.UpdateConfigurationSetTrackingOptions
* @see AWS API Documentation
*/
@Override
public UpdateConfigurationSetTrackingOptionsResult updateConfigurationSetTrackingOptions(UpdateConfigurationSetTrackingOptionsRequest request) {
request = beforeClientExecution(request);
return executeUpdateConfigurationSetTrackingOptions(request);
}
@SdkInternalApi
final UpdateConfigurationSetTrackingOptionsResult executeUpdateConfigurationSetTrackingOptions(
UpdateConfigurationSetTrackingOptionsRequest updateConfigurationSetTrackingOptionsRequest) {
ExecutionContext executionContext = createExecutionContext(updateConfigurationSetTrackingOptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateConfigurationSetTrackingOptionsRequestMarshaller().marshall(super
.beforeMarshalling(updateConfigurationSetTrackingOptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateConfigurationSetTrackingOptions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new UpdateConfigurationSetTrackingOptionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an existing custom verification email template.
*
*
* For more information about custom verification email templates, see Using
* Custom Verification Email Templates in the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param updateCustomVerificationEmailTemplateRequest
* Represents a request to update an existing custom verification email template.
* @return Result of the UpdateCustomVerificationEmailTemplate operation returned by the service.
* @throws CustomVerificationEmailTemplateDoesNotExistException
* Indicates that a custom verification email template with the name you specified does not exist.
* @throws FromEmailAddressNotVerifiedException
* Indicates that the sender address specified for a custom verification email is not verified, and is
* therefore not eligible to send the custom verification email.
* @throws CustomVerificationEmailInvalidContentException
* Indicates that custom verification email template provided content is invalid.
* @sample AmazonSimpleEmailService.UpdateCustomVerificationEmailTemplate
* @see AWS API Documentation
*/
@Override
public UpdateCustomVerificationEmailTemplateResult updateCustomVerificationEmailTemplate(UpdateCustomVerificationEmailTemplateRequest request) {
request = beforeClientExecution(request);
return executeUpdateCustomVerificationEmailTemplate(request);
}
@SdkInternalApi
final UpdateCustomVerificationEmailTemplateResult executeUpdateCustomVerificationEmailTemplate(
UpdateCustomVerificationEmailTemplateRequest updateCustomVerificationEmailTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(updateCustomVerificationEmailTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateCustomVerificationEmailTemplateRequestMarshaller().marshall(super
.beforeMarshalling(updateCustomVerificationEmailTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateCustomVerificationEmailTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new UpdateCustomVerificationEmailTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a receipt rule.
*
*
* For information about managing receipt rules, see the Amazon
* SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param updateReceiptRuleRequest
* Represents a request to update a receipt rule. You use receipt rules to receive email with Amazon SES. For
* more information, see the Amazon SES Developer
* Guide.
* @return Result of the UpdateReceiptRule operation returned by the service.
* @throws InvalidSnsTopicException
* Indicates that the provided Amazon SNS topic is invalid, or that Amazon SES could not publish to the
* topic, possibly due to permissions issues. For information about giving permissions, see the Amazon SES
* Developer Guide.
* @throws InvalidS3ConfigurationException
* Indicates that the provided Amazon S3 bucket or Amazon Web Services KMS encryption key is invalid, or
* that Amazon SES could not publish to the bucket, possibly due to permissions issues. For information
* about giving permissions, see the Amazon SES
* Developer Guide.
* @throws InvalidLambdaFunctionException
* Indicates that the provided Amazon Web Services Lambda function is invalid, or that Amazon SES could not
* execute the provided function, possibly due to permissions issues. For information about giving
* permissions, see the Amazon SES
* Developer Guide.
* @throws RuleSetDoesNotExistException
* Indicates that the provided receipt rule set does not exist.
* @throws RuleDoesNotExistException
* Indicates that the provided receipt rule does not exist.
* @throws LimitExceededException
* Indicates that a resource could not be created because of service limits. For a list of Amazon SES
* limits, see the Amazon SES
* Developer Guide.
* @sample AmazonSimpleEmailService.UpdateReceiptRule
* @see AWS API
* Documentation
*/
@Override
public UpdateReceiptRuleResult updateReceiptRule(UpdateReceiptRuleRequest request) {
request = beforeClientExecution(request);
return executeUpdateReceiptRule(request);
}
@SdkInternalApi
final UpdateReceiptRuleResult executeUpdateReceiptRule(UpdateReceiptRuleRequest updateReceiptRuleRequest) {
ExecutionContext executionContext = createExecutionContext(updateReceiptRuleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateReceiptRuleRequestMarshaller().marshall(super.beforeMarshalling(updateReceiptRuleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateReceiptRule");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new UpdateReceiptRuleResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an email template. Email templates enable you to send personalized email to one or more destinations in a
* single operation. For more information, see the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param updateTemplateRequest
* @return Result of the UpdateTemplate operation returned by the service.
* @throws TemplateDoesNotExistException
* Indicates that the Template object you specified does not exist in your Amazon SES account.
* @throws InvalidTemplateException
* Indicates that the template that you specified could not be rendered. This issue may occur when a
* template refers to a partial that does not exist.
* @sample AmazonSimpleEmailService.UpdateTemplate
* @see AWS API
* Documentation
*/
@Override
public UpdateTemplateResult updateTemplate(UpdateTemplateRequest request) {
request = beforeClientExecution(request);
return executeUpdateTemplate(request);
}
@SdkInternalApi
final UpdateTemplateResult executeUpdateTemplate(UpdateTemplateRequest updateTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(updateTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateTemplateRequestMarshaller().marshall(super.beforeMarshalling(updateTemplateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new UpdateTemplateResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a set of DKIM tokens for a domain identity.
*
*
*
* When you execute the VerifyDomainDkim operation, the domain that you specify is added to the list of
* identities that are associated with your account. This is true even if you haven't already associated the domain
* with your account by using the VerifyDomainIdentity operation. However, you can't send email from
* the domain until you either successfully verify it
* or you successfully set up DKIM for it.
*
*
*
* You use the tokens that are generated by this operation to create CNAME records. When Amazon SES detects that
* you've added these records to the DNS configuration for a domain, you can start sending email from that domain.
* You can start sending email even if you haven't added the TXT record provided by the VerifyDomainIdentity
* operation to the DNS configuration for your domain. All email that you send from the domain is authenticated
* using DKIM.
*
*
* To create the CNAME records for DKIM authentication, use the following values:
*
*
* -
*
* Name: token._domainkey.example.com
*
*
* -
*
* Type: CNAME
*
*
* -
*
* Value: token.dkim.amazonses.com
*
*
*
*
* In the preceding example, replace token with one of the tokens that are generated when you execute this
* operation. Replace example.com with your domain. Repeat this process for each token that's generated by
* this operation.
*
*
* You can execute this operation no more than once per second.
*
*
* @param verifyDomainDkimRequest
* Represents a request to generate the CNAME records needed to set up Easy DKIM with Amazon SES. For more
* information about setting up Easy DKIM, see the Amazon SES
* Developer Guide.
* @return Result of the VerifyDomainDkim operation returned by the service.
* @sample AmazonSimpleEmailService.VerifyDomainDkim
* @see AWS API
* Documentation
*/
@Override
public VerifyDomainDkimResult verifyDomainDkim(VerifyDomainDkimRequest request) {
request = beforeClientExecution(request);
return executeVerifyDomainDkim(request);
}
@SdkInternalApi
final VerifyDomainDkimResult executeVerifyDomainDkim(VerifyDomainDkimRequest verifyDomainDkimRequest) {
ExecutionContext executionContext = createExecutionContext(verifyDomainDkimRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new VerifyDomainDkimRequestMarshaller().marshall(super.beforeMarshalling(verifyDomainDkimRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "VerifyDomainDkim");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new VerifyDomainDkimResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds a domain to the list of identities for your Amazon SES account in the current Amazon Web Services Region and
* attempts to verify it. For more information about verifying domains, see Verifying Email Addresses and
* Domains in the Amazon SES Developer Guide.
*
*
* You can execute this operation no more than once per second.
*
*
* @param verifyDomainIdentityRequest
* Represents a request to begin Amazon SES domain verification and to generate the TXT records that you must
* publish to the DNS server of your domain to complete the verification. For information about domain
* verification, see the Amazon
* SES Developer Guide.
* @return Result of the VerifyDomainIdentity operation returned by the service.
* @sample AmazonSimpleEmailService.VerifyDomainIdentity
* @see AWS API
* Documentation
*/
@Override
public VerifyDomainIdentityResult verifyDomainIdentity(VerifyDomainIdentityRequest request) {
request = beforeClientExecution(request);
return executeVerifyDomainIdentity(request);
}
@SdkInternalApi
final VerifyDomainIdentityResult executeVerifyDomainIdentity(VerifyDomainIdentityRequest verifyDomainIdentityRequest) {
ExecutionContext executionContext = createExecutionContext(verifyDomainIdentityRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new VerifyDomainIdentityRequestMarshaller().marshall(super.beforeMarshalling(verifyDomainIdentityRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "VerifyDomainIdentity");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new VerifyDomainIdentityResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deprecated. Use the VerifyEmailIdentity operation to verify a new email address.
*
*
* @param verifyEmailAddressRequest
* Represents a request to begin email address verification with Amazon SES. For information about email
* address verification, see the Amazon SES Developer Guide.
* @return Result of the VerifyEmailAddress operation returned by the service.
* @sample AmazonSimpleEmailService.VerifyEmailAddress
* @see AWS API
* Documentation
*/
@Override
public VerifyEmailAddressResult verifyEmailAddress(VerifyEmailAddressRequest request) {
request = beforeClientExecution(request);
return executeVerifyEmailAddress(request);
}
@SdkInternalApi
final VerifyEmailAddressResult executeVerifyEmailAddress(VerifyEmailAddressRequest verifyEmailAddressRequest) {
ExecutionContext executionContext = createExecutionContext(verifyEmailAddressRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new VerifyEmailAddressRequestMarshaller().marshall(super.beforeMarshalling(verifyEmailAddressRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "VerifyEmailAddress");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new VerifyEmailAddressResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds an email address to the list of identities for your Amazon SES account in the current Amazon Web Services
* Region and attempts to verify it. As a result of executing this operation, a verification email is sent to the
* specified address.
*
*
* You can execute this operation no more than once per second.
*
*
* @param verifyEmailIdentityRequest
* Represents a request to begin email address verification with Amazon SES. For information about email
* address verification, see the Amazon SES Developer Guide.
* @return Result of the VerifyEmailIdentity operation returned by the service.
* @sample AmazonSimpleEmailService.VerifyEmailIdentity
* @see AWS API
* Documentation
*/
@Override
public VerifyEmailIdentityResult verifyEmailIdentity(VerifyEmailIdentityRequest request) {
request = beforeClientExecution(request);
return executeVerifyEmailIdentity(request);
}
@SdkInternalApi
final VerifyEmailIdentityResult executeVerifyEmailIdentity(VerifyEmailIdentityRequest verifyEmailIdentityRequest) {
ExecutionContext executionContext = createExecutionContext(verifyEmailIdentityRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new VerifyEmailIdentityRequestMarshaller().marshall(super.beforeMarshalling(verifyEmailIdentityRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SES");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "VerifyEmailIdentity");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new VerifyEmailIdentityResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallersMap, defaultUnmarshaller);
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@Override
public AmazonSimpleEmailServiceWaiters waiters() {
if (waiters == null) {
synchronized (this) {
if (waiters == null) {
waiters = new AmazonSimpleEmailServiceWaiters(this);
}
}
}
return waiters;
}
@Override
public void shutdown() {
super.shutdown();
if (waiters != null) {
waiters.shutdown();
}
}
}