• Home
• com.amazonaws
• aws-java-sdk-deadline
• 1.12.780
• source code
• AWSDeadlineAsyncClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.amazonaws.services.deadline.AWSDeadlineAsyncClient Maven / Gradle / Ivy

/*
 * 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.deadline;

import javax.annotation.Generated;

import com.amazonaws.services.deadline.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;

import java.util.concurrent.ExecutorService;

/**
 * Client for accessing AWSDeadlineCloud asynchronously. Each asynchronous method will return a Java Future object
 * representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
 * notification when an asynchronous operation completes.
 * 

 * 

 * The Amazon Web Services Deadline Cloud API provides infrastructure and centralized management for your projects. Use
 * the Deadline Cloud API to onboard users, assign projects, and attach permissions specific to their job function.
 * 
 * 

 * With Deadline Cloud, content production teams can deploy resources for their workforce securely in the cloud,
 * reducing the costs of added physical infrastructure. Keep your content production operations secure, while allowing
 * your contributors to access the tools they need, such as scalable high-speed storage, licenses, and cost management
 * services.
 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSDeadlineAsyncClient extends AWSDeadlineClient implements AWSDeadlineAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

    public static AWSDeadlineAsyncClientBuilder asyncBuilder() {
        return AWSDeadlineAsyncClientBuilder.standard();
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on AWSDeadlineCloud using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     */
    AWSDeadlineAsyncClient(AwsAsyncClientParams asyncClientParams) {
        this(asyncClientParams, false);
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on AWSDeadlineCloud using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     * @param endpointDiscoveryEnabled
     *        true will enable endpoint discovery if the service supports it.
     */
    AWSDeadlineAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
        super(asyncClientParams, endpointDiscoveryEnabled);
        this.executorService = asyncClientParams.getExecutor();
    }

    /**
     * Returns the executor service used by this client to execute async requests.
     *
     * @return The executor service used by this client to execute async requests.
     */
    public ExecutorService getExecutorService() {
        return executorService;
    }

    @Override
    public java.util.concurrent.Future associateMemberToFarmAsync(AssociateMemberToFarmRequest request) {

        return associateMemberToFarmAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateMemberToFarmAsync(final AssociateMemberToFarmRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateMemberToFarmRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateMemberToFarmResult call() throws Exception {
                AssociateMemberToFarmResult result = null;

                try {
                    result = executeAssociateMemberToFarm(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateMemberToFleetAsync(AssociateMemberToFleetRequest request) {

        return associateMemberToFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateMemberToFleetAsync(final AssociateMemberToFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateMemberToFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateMemberToFleetResult call() throws Exception {
                AssociateMemberToFleetResult result = null;

                try {
                    result = executeAssociateMemberToFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateMemberToJobAsync(AssociateMemberToJobRequest request) {

        return associateMemberToJobAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateMemberToJobAsync(final AssociateMemberToJobRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateMemberToJobRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateMemberToJobResult call() throws Exception {
                AssociateMemberToJobResult result = null;

                try {
                    result = executeAssociateMemberToJob(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateMemberToQueueAsync(AssociateMemberToQueueRequest request) {

        return associateMemberToQueueAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateMemberToQueueAsync(final AssociateMemberToQueueRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateMemberToQueueRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateMemberToQueueResult call() throws Exception {
                AssociateMemberToQueueResult result = null;

                try {
                    result = executeAssociateMemberToQueue(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future assumeFleetRoleForReadAsync(AssumeFleetRoleForReadRequest request) {

        return assumeFleetRoleForReadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future assumeFleetRoleForReadAsync(final AssumeFleetRoleForReadRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssumeFleetRoleForReadRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssumeFleetRoleForReadResult call() throws Exception {
                AssumeFleetRoleForReadResult result = null;

                try {
                    result = executeAssumeFleetRoleForRead(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future assumeFleetRoleForWorkerAsync(AssumeFleetRoleForWorkerRequest request) {

        return assumeFleetRoleForWorkerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future assumeFleetRoleForWorkerAsync(final AssumeFleetRoleForWorkerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssumeFleetRoleForWorkerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssumeFleetRoleForWorkerResult call() throws Exception {
                AssumeFleetRoleForWorkerResult result = null;

                try {
                    result = executeAssumeFleetRoleForWorker(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future assumeQueueRoleForReadAsync(AssumeQueueRoleForReadRequest request) {

        return assumeQueueRoleForReadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future assumeQueueRoleForReadAsync(final AssumeQueueRoleForReadRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssumeQueueRoleForReadRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssumeQueueRoleForReadResult call() throws Exception {
                AssumeQueueRoleForReadResult result = null;

                try {
                    result = executeAssumeQueueRoleForRead(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future assumeQueueRoleForUserAsync(AssumeQueueRoleForUserRequest request) {

        return assumeQueueRoleForUserAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future assumeQueueRoleForUserAsync(final AssumeQueueRoleForUserRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssumeQueueRoleForUserRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssumeQueueRoleForUserResult call() throws Exception {
                AssumeQueueRoleForUserResult result = null;

                try {
                    result = executeAssumeQueueRoleForUser(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future assumeQueueRoleForWorkerAsync(AssumeQueueRoleForWorkerRequest request) {

        return assumeQueueRoleForWorkerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future assumeQueueRoleForWorkerAsync(final AssumeQueueRoleForWorkerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssumeQueueRoleForWorkerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssumeQueueRoleForWorkerResult call() throws Exception {
                AssumeQueueRoleForWorkerResult result = null;

                try {
                    result = executeAssumeQueueRoleForWorker(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future batchGetJobEntityAsync(BatchGetJobEntityRequest request) {

        return batchGetJobEntityAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future batchGetJobEntityAsync(final BatchGetJobEntityRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final BatchGetJobEntityRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public BatchGetJobEntityResult call() throws Exception {
                BatchGetJobEntityResult result = null;

                try {
                    result = executeBatchGetJobEntity(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future copyJobTemplateAsync(CopyJobTemplateRequest request) {

        return copyJobTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future copyJobTemplateAsync(final CopyJobTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CopyJobTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CopyJobTemplateResult call() throws Exception {
                CopyJobTemplateResult result = null;

                try {
                    result = executeCopyJobTemplate(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createBudgetAsync(CreateBudgetRequest request) {

        return createBudgetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createBudgetAsync(final CreateBudgetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateBudgetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateBudgetResult call() throws Exception {
                CreateBudgetResult result = null;

                try {
                    result = executeCreateBudget(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createFarmAsync(CreateFarmRequest request) {

        return createFarmAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createFarmAsync(final CreateFarmRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateFarmRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateFarmResult call() throws Exception {
                CreateFarmResult result = null;

                try {
                    result = executeCreateFarm(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createFleetAsync(CreateFleetRequest request) {

        return createFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createFleetAsync(final CreateFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateFleetResult call() throws Exception {
                CreateFleetResult result = null;

                try {
                    result = executeCreateFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createJobAsync(CreateJobRequest request) {

        return createJobAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createJobAsync(final CreateJobRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateJobRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateJobResult call() throws Exception {
                CreateJobResult result = null;

                try {
                    result = executeCreateJob(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createLicenseEndpointAsync(CreateLicenseEndpointRequest request) {

        return createLicenseEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createLicenseEndpointAsync(final CreateLicenseEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateLicenseEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateLicenseEndpointResult call() throws Exception {
                CreateLicenseEndpointResult result = null;

                try {
                    result = executeCreateLicenseEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createMonitorAsync(CreateMonitorRequest request) {

        return createMonitorAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createMonitorAsync(final CreateMonitorRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateMonitorRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateMonitorResult call() throws Exception {
                CreateMonitorResult result = null;

                try {
                    result = executeCreateMonitor(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createQueueAsync(CreateQueueRequest request) {

        return createQueueAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createQueueAsync(final CreateQueueRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateQueueRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateQueueResult call() throws Exception {
                CreateQueueResult result = null;

                try {
                    result = executeCreateQueue(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createQueueEnvironmentAsync(CreateQueueEnvironmentRequest request) {

        return createQueueEnvironmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createQueueEnvironmentAsync(final CreateQueueEnvironmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateQueueEnvironmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateQueueEnvironmentResult call() throws Exception {
                CreateQueueEnvironmentResult result = null;

                try {
                    result = executeCreateQueueEnvironment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createQueueFleetAssociationAsync(CreateQueueFleetAssociationRequest request) {

        return createQueueFleetAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createQueueFleetAssociationAsync(final CreateQueueFleetAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateQueueFleetAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateQueueFleetAssociationResult call() throws Exception {
                CreateQueueFleetAssociationResult result = null;

                try {
                    result = executeCreateQueueFleetAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createStorageProfileAsync(CreateStorageProfileRequest request) {

        return createStorageProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createStorageProfileAsync(final CreateStorageProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateStorageProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateStorageProfileResult call() throws Exception {
                CreateStorageProfileResult result = null;

                try {
                    result = executeCreateStorageProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createWorkerAsync(CreateWorkerRequest request) {

        return createWorkerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createWorkerAsync(final CreateWorkerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateWorkerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateWorkerResult call() throws Exception {
                CreateWorkerResult result = null;

                try {
                    result = executeCreateWorker(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteBudgetAsync(DeleteBudgetRequest request) {

        return deleteBudgetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteBudgetAsync(final DeleteBudgetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteBudgetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteBudgetResult call() throws Exception {
                DeleteBudgetResult result = null;

                try {
                    result = executeDeleteBudget(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteFarmAsync(DeleteFarmRequest request) {

        return deleteFarmAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteFarmAsync(final DeleteFarmRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteFarmRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteFarmResult call() throws Exception {
                DeleteFarmResult result = null;

                try {
                    result = executeDeleteFarm(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteFleetAsync(DeleteFleetRequest request) {

        return deleteFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteFleetAsync(final DeleteFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteFleetResult call() throws Exception {
                DeleteFleetResult result = null;

                try {
                    result = executeDeleteFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteLicenseEndpointAsync(DeleteLicenseEndpointRequest request) {

        return deleteLicenseEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteLicenseEndpointAsync(final DeleteLicenseEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteLicenseEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteLicenseEndpointResult call() throws Exception {
                DeleteLicenseEndpointResult result = null;

                try {
                    result = executeDeleteLicenseEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteMeteredProductAsync(DeleteMeteredProductRequest request) {

        return deleteMeteredProductAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteMeteredProductAsync(final DeleteMeteredProductRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteMeteredProductRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteMeteredProductResult call() throws Exception {
                DeleteMeteredProductResult result = null;

                try {
                    result = executeDeleteMeteredProduct(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteMonitorAsync(DeleteMonitorRequest request) {

        return deleteMonitorAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteMonitorAsync(final DeleteMonitorRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteMonitorRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteMonitorResult call() throws Exception {
                DeleteMonitorResult result = null;

                try {
                    result = executeDeleteMonitor(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteQueueAsync(DeleteQueueRequest request) {

        return deleteQueueAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteQueueAsync(final DeleteQueueRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteQueueRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteQueueResult call() throws Exception {
                DeleteQueueResult result = null;

                try {
                    result = executeDeleteQueue(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteQueueEnvironmentAsync(DeleteQueueEnvironmentRequest request) {

        return deleteQueueEnvironmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteQueueEnvironmentAsync(final DeleteQueueEnvironmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteQueueEnvironmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteQueueEnvironmentResult call() throws Exception {
                DeleteQueueEnvironmentResult result = null;

                try {
                    result = executeDeleteQueueEnvironment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteQueueFleetAssociationAsync(DeleteQueueFleetAssociationRequest request) {

        return deleteQueueFleetAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteQueueFleetAssociationAsync(final DeleteQueueFleetAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteQueueFleetAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteQueueFleetAssociationResult call() throws Exception {
                DeleteQueueFleetAssociationResult result = null;

                try {
                    result = executeDeleteQueueFleetAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteStorageProfileAsync(DeleteStorageProfileRequest request) {

        return deleteStorageProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteStorageProfileAsync(final DeleteStorageProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteStorageProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteStorageProfileResult call() throws Exception {
                DeleteStorageProfileResult result = null;

                try {
                    result = executeDeleteStorageProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteWorkerAsync(DeleteWorkerRequest request) {

        return deleteWorkerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteWorkerAsync(final DeleteWorkerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteWorkerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteWorkerResult call() throws Exception {
                DeleteWorkerResult result = null;

                try {
                    result = executeDeleteWorker(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateMemberFromFarmAsync(DisassociateMemberFromFarmRequest request) {

        return disassociateMemberFromFarmAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateMemberFromFarmAsync(final DisassociateMemberFromFarmRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateMemberFromFarmRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateMemberFromFarmResult call() throws Exception {
                DisassociateMemberFromFarmResult result = null;

                try {
                    result = executeDisassociateMemberFromFarm(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateMemberFromFleetAsync(DisassociateMemberFromFleetRequest request) {

        return disassociateMemberFromFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateMemberFromFleetAsync(final DisassociateMemberFromFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateMemberFromFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateMemberFromFleetResult call() throws Exception {
                DisassociateMemberFromFleetResult result = null;

                try {
                    result = executeDisassociateMemberFromFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateMemberFromJobAsync(DisassociateMemberFromJobRequest request) {

        return disassociateMemberFromJobAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateMemberFromJobAsync(final DisassociateMemberFromJobRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateMemberFromJobRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateMemberFromJobResult call() throws Exception {
                DisassociateMemberFromJobResult result = null;

                try {
                    result = executeDisassociateMemberFromJob(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateMemberFromQueueAsync(DisassociateMemberFromQueueRequest request) {

        return disassociateMemberFromQueueAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateMemberFromQueueAsync(final DisassociateMemberFromQueueRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateMemberFromQueueRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateMemberFromQueueResult call() throws Exception {
                DisassociateMemberFromQueueResult result = null;

                try {
                    result = executeDisassociateMemberFromQueue(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getBudgetAsync(GetBudgetRequest request) {

        return getBudgetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getBudgetAsync(final GetBudgetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetBudgetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetBudgetResult call() throws Exception {
                GetBudgetResult result = null;

                try {
                    result = executeGetBudget(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getFarmAsync(GetFarmRequest request) {

        return getFarmAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getFarmAsync(final GetFarmRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetFarmRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetFarmResult call() throws Exception {
                GetFarmResult result = null;

                try {
                    result = executeGetFarm(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getFleetAsync(GetFleetRequest request) {

        return getFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getFleetAsync(final GetFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetFleetResult call() throws Exception {
                GetFleetResult result = null;

                try {
                    result = executeGetFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getJobAsync(GetJobRequest request) {

        return getJobAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getJobAsync(final GetJobRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetJobRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetJobResult call() throws Exception {
                GetJobResult result = null;

                try {
                    result = executeGetJob(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getLicenseEndpointAsync(GetLicenseEndpointRequest request) {

        return getLicenseEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getLicenseEndpointAsync(final GetLicenseEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetLicenseEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetLicenseEndpointResult call() throws Exception {
                GetLicenseEndpointResult result = null;

                try {
                    result = executeGetLicenseEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getMonitorAsync(GetMonitorRequest request) {

        return getMonitorAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getMonitorAsync(final GetMonitorRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetMonitorRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetMonitorResult call() throws Exception {
                GetMonitorResult result = null;

                try {
                    result = executeGetMonitor(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getQueueAsync(GetQueueRequest request) {

        return getQueueAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getQueueAsync(final GetQueueRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetQueueRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetQueueResult call() throws Exception {
                GetQueueResult result = null;

                try {
                    result = executeGetQueue(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getQueueEnvironmentAsync(GetQueueEnvironmentRequest request) {

        return getQueueEnvironmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getQueueEnvironmentAsync(final GetQueueEnvironmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetQueueEnvironmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetQueueEnvironmentResult call() throws Exception {
                GetQueueEnvironmentResult result = null;

                try {
                    result = executeGetQueueEnvironment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getQueueFleetAssociationAsync(GetQueueFleetAssociationRequest request) {

        return getQueueFleetAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getQueueFleetAssociationAsync(final GetQueueFleetAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetQueueFleetAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetQueueFleetAssociationResult call() throws Exception {
                GetQueueFleetAssociationResult result = null;

                try {
                    result = executeGetQueueFleetAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getSessionAsync(GetSessionRequest request) {

        return getSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getSessionAsync(final GetSessionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetSessionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetSessionResult call() throws Exception {
                GetSessionResult result = null;

                try {
                    result = executeGetSession(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getSessionActionAsync(GetSessionActionRequest request) {

        return getSessionActionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getSessionActionAsync(final GetSessionActionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetSessionActionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetSessionActionResult call() throws Exception {
                GetSessionActionResult result = null;

                try {
                    result = executeGetSessionAction(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getSessionsStatisticsAggregationAsync(
            GetSessionsStatisticsAggregationRequest request) {

        return getSessionsStatisticsAggregationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getSessionsStatisticsAggregationAsync(
            final GetSessionsStatisticsAggregationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetSessionsStatisticsAggregationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetSessionsStatisticsAggregationResult call() throws Exception {
                GetSessionsStatisticsAggregationResult result = null;

                try {
                    result = executeGetSessionsStatisticsAggregation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getStepAsync(GetStepRequest request) {

        return getStepAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getStepAsync(final GetStepRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetStepRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetStepResult call() throws Exception {
                GetStepResult result = null;

                try {
                    result = executeGetStep(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getStorageProfileAsync(GetStorageProfileRequest request) {

        return getStorageProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getStorageProfileAsync(final GetStorageProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetStorageProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetStorageProfileResult call() throws Exception {
                GetStorageProfileResult result = null;

                try {
                    result = executeGetStorageProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getStorageProfileForQueueAsync(GetStorageProfileForQueueRequest request) {

        return getStorageProfileForQueueAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getStorageProfileForQueueAsync(final GetStorageProfileForQueueRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetStorageProfileForQueueRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetStorageProfileForQueueResult call() throws Exception {
                GetStorageProfileForQueueResult result = null;

                try {
                    result = executeGetStorageProfileForQueue(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getTaskAsync(GetTaskRequest request) {

        return getTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getTaskAsync(final GetTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetTaskResult call() throws Exception {
                GetTaskResult result = null;

                try {
                    result = executeGetTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getWorkerAsync(GetWorkerRequest request) {

        return getWorkerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getWorkerAsync(final GetWorkerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetWorkerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetWorkerResult call() throws Exception {
                GetWorkerResult result = null;

                try {
                    result = executeGetWorker(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listAvailableMeteredProductsAsync(ListAvailableMeteredProductsRequest request) {

        return listAvailableMeteredProductsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listAvailableMeteredProductsAsync(final ListAvailableMeteredProductsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListAvailableMeteredProductsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListAvailableMeteredProductsResult call() throws Exception {
                ListAvailableMeteredProductsResult result = null;

                try {
                    result = executeListAvailableMeteredProducts(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listBudgetsAsync(ListBudgetsRequest request) {

        return listBudgetsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listBudgetsAsync(final ListBudgetsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListBudgetsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListBudgetsResult call() throws Exception {
                ListBudgetsResult result = null;

                try {
                    result = executeListBudgets(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listFarmMembersAsync(ListFarmMembersRequest request) {

        return listFarmMembersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listFarmMembersAsync(final ListFarmMembersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListFarmMembersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListFarmMembersResult call() throws Exception {
                ListFarmMembersResult result = null;

                try {
                    result = executeListFarmMembers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listFarmsAsync(ListFarmsRequest request) {

        return listFarmsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listFarmsAsync(final ListFarmsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListFarmsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListFarmsResult call() throws Exception {
                ListFarmsResult result = null;

                try {
                    result = executeListFarms(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listFleetMembersAsync(ListFleetMembersRequest request) {

        return listFleetMembersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listFleetMembersAsync(final ListFleetMembersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListFleetMembersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListFleetMembersResult call() throws Exception {
                ListFleetMembersResult result = null;

                try {
                    result = executeListFleetMembers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listFleetsAsync(ListFleetsRequest request) {

        return listFleetsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listFleetsAsync(final ListFleetsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListFleetsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListFleetsResult call() throws Exception {
                ListFleetsResult result = null;

                try {
                    result = executeListFleets(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listJobMembersAsync(ListJobMembersRequest request) {

        return listJobMembersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listJobMembersAsync(final ListJobMembersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListJobMembersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListJobMembersResult call() throws Exception {
                ListJobMembersResult result = null;

                try {
                    result = executeListJobMembers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listJobsAsync(ListJobsRequest request) {

        return listJobsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listJobsAsync(final ListJobsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListJobsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListJobsResult call() throws Exception {
                ListJobsResult result = null;

                try {
                    result = executeListJobs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listLicenseEndpointsAsync(ListLicenseEndpointsRequest request) {

        return listLicenseEndpointsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listLicenseEndpointsAsync(final ListLicenseEndpointsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListLicenseEndpointsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListLicenseEndpointsResult call() throws Exception {
                ListLicenseEndpointsResult result = null;

                try {
                    result = executeListLicenseEndpoints(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listMeteredProductsAsync(ListMeteredProductsRequest request) {

        return listMeteredProductsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listMeteredProductsAsync(final ListMeteredProductsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListMeteredProductsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListMeteredProductsResult call() throws Exception {
                ListMeteredProductsResult result = null;

                try {
                    result = executeListMeteredProducts(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listMonitorsAsync(ListMonitorsRequest request) {

        return listMonitorsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listMonitorsAsync(final ListMonitorsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListMonitorsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListMonitorsResult call() throws Exception {
                ListMonitorsResult result = null;

                try {
                    result = executeListMonitors(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listQueueEnvironmentsAsync(ListQueueEnvironmentsRequest request) {

        return listQueueEnvironmentsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listQueueEnvironmentsAsync(final ListQueueEnvironmentsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListQueueEnvironmentsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListQueueEnvironmentsResult call() throws Exception {
                ListQueueEnvironmentsResult result = null;

                try {
                    result = executeListQueueEnvironments(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listQueueFleetAssociationsAsync(ListQueueFleetAssociationsRequest request) {

        return listQueueFleetAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listQueueFleetAssociationsAsync(final ListQueueFleetAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListQueueFleetAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListQueueFleetAssociationsResult call() throws Exception {
                ListQueueFleetAssociationsResult result = null;

                try {
                    result = executeListQueueFleetAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listQueueMembersAsync(ListQueueMembersRequest request) {

        return listQueueMembersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listQueueMembersAsync(final ListQueueMembersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListQueueMembersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListQueueMembersResult call() throws Exception {
                ListQueueMembersResult result = null;

                try {
                    result = executeListQueueMembers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listQueuesAsync(ListQueuesRequest request) {

        return listQueuesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listQueuesAsync(final ListQueuesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListQueuesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListQueuesResult call() throws Exception {
                ListQueuesResult result = null;

                try {
                    result = executeListQueues(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listSessionActionsAsync(ListSessionActionsRequest request) {

        return listSessionActionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listSessionActionsAsync(final ListSessionActionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListSessionActionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListSessionActionsResult call() throws Exception {
                ListSessionActionsResult result = null;

                try {
                    result = executeListSessionActions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listSessionsAsync(ListSessionsRequest request) {

        return listSessionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listSessionsAsync(final ListSessionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListSessionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListSessionsResult call() throws Exception {
                ListSessionsResult result = null;

                try {
                    result = executeListSessions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listSessionsForWorkerAsync(ListSessionsForWorkerRequest request) {

        return listSessionsForWorkerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listSessionsForWorkerAsync(final ListSessionsForWorkerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListSessionsForWorkerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListSessionsForWorkerResult call() throws Exception {
                ListSessionsForWorkerResult result = null;

                try {
                    result = executeListSessionsForWorker(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listStepConsumersAsync(ListStepConsumersRequest request) {

        return listStepConsumersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listStepConsumersAsync(final ListStepConsumersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListStepConsumersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListStepConsumersResult call() throws Exception {
                ListStepConsumersResult result = null;

                try {
                    result = executeListStepConsumers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listStepDependenciesAsync(ListStepDependenciesRequest request) {

        return listStepDependenciesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listStepDependenciesAsync(final ListStepDependenciesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListStepDependenciesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListStepDependenciesResult call() throws Exception {
                ListStepDependenciesResult result = null;

                try {
                    result = executeListStepDependencies(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listStepsAsync(ListStepsRequest request) {

        return listStepsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listStepsAsync(final ListStepsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListStepsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListStepsResult call() throws Exception {
                ListStepsResult result = null;

                try {
                    result = executeListSteps(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listStorageProfilesAsync(ListStorageProfilesRequest request) {

        return listStorageProfilesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listStorageProfilesAsync(final ListStorageProfilesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListStorageProfilesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListStorageProfilesResult call() throws Exception {
                ListStorageProfilesResult result = null;

                try {
                    result = executeListStorageProfiles(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listStorageProfilesForQueueAsync(ListStorageProfilesForQueueRequest request) {

        return listStorageProfilesForQueueAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listStorageProfilesForQueueAsync(final ListStorageProfilesForQueueRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListStorageProfilesForQueueRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListStorageProfilesForQueueResult call() throws Exception {
                ListStorageProfilesForQueueResult result = null;

                try {
                    result = executeListStorageProfilesForQueue(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest request) {

        return listTagsForResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listTagsForResourceAsync(final ListTagsForResourceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListTagsForResourceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListTagsForResourceResult call() throws Exception {
                ListTagsForResourceResult result = null;

                try {
                    result = executeListTagsForResource(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listTasksAsync(ListTasksRequest request) {

        return listTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listTasksAsync(final ListTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListTasksResult call() throws Exception {
                ListTasksResult result = null;

                try {
                    result = executeListTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listWorkersAsync(ListWorkersRequest request) {

        return listWorkersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listWorkersAsync(final ListWorkersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListWorkersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListWorkersResult call() throws Exception {
                ListWorkersResult result = null;

                try {
                    result = executeListWorkers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future putMeteredProductAsync(PutMeteredProductRequest request) {

        return putMeteredProductAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future putMeteredProductAsync(final PutMeteredProductRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final PutMeteredProductRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public PutMeteredProductResult call() throws Exception {
                PutMeteredProductResult result = null;

                try {
                    result = executePutMeteredProduct(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchJobsAsync(SearchJobsRequest request) {

        return searchJobsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchJobsAsync(final SearchJobsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchJobsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchJobsResult call() throws Exception {
                SearchJobsResult result = null;

                try {
                    result = executeSearchJobs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchStepsAsync(SearchStepsRequest request) {

        return searchStepsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchStepsAsync(final SearchStepsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchStepsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchStepsResult call() throws Exception {
                SearchStepsResult result = null;

                try {
                    result = executeSearchSteps(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchTasksAsync(SearchTasksRequest request) {

        return searchTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchTasksAsync(final SearchTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchTasksResult call() throws Exception {
                SearchTasksResult result = null;

                try {
                    result = executeSearchTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchWorkersAsync(SearchWorkersRequest request) {

        return searchWorkersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchWorkersAsync(final SearchWorkersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchWorkersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchWorkersResult call() throws Exception {
                SearchWorkersResult result = null;

                try {
                    result = executeSearchWorkers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future startSessionsStatisticsAggregationAsync(
            StartSessionsStatisticsAggregationRequest request) {

        return startSessionsStatisticsAggregationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future startSessionsStatisticsAggregationAsync(
            final StartSessionsStatisticsAggregationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final StartSessionsStatisticsAggregationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public StartSessionsStatisticsAggregationResult call() throws Exception {
                StartSessionsStatisticsAggregationResult result = null;

                try {
                    result = executeStartSessionsStatisticsAggregation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future tagResourceAsync(TagResourceRequest request) {

        return tagResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future tagResourceAsync(final TagResourceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final TagResourceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public TagResourceResult call() throws Exception {
                TagResourceResult result = null;

                try {
                    result = executeTagResource(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future untagResourceAsync(UntagResourceRequest request) {

        return untagResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future untagResourceAsync(final UntagResourceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UntagResourceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UntagResourceResult call() throws Exception {
                UntagResourceResult result = null;

                try {
                    result = executeUntagResource(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateBudgetAsync(UpdateBudgetRequest request) {

        return updateBudgetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateBudgetAsync(final UpdateBudgetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateBudgetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateBudgetResult call() throws Exception {
                UpdateBudgetResult result = null;

                try {
                    result = executeUpdateBudget(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateFarmAsync(UpdateFarmRequest request) {

        return updateFarmAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateFarmAsync(final UpdateFarmRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateFarmRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateFarmResult call() throws Exception {
                UpdateFarmResult result = null;

                try {
                    result = executeUpdateFarm(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateFleetAsync(UpdateFleetRequest request) {

        return updateFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateFleetAsync(final UpdateFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateFleetResult call() throws Exception {
                UpdateFleetResult result = null;

                try {
                    result = executeUpdateFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateJobAsync(UpdateJobRequest request) {

        return updateJobAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateJobAsync(final UpdateJobRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateJobRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateJobResult call() throws Exception {
                UpdateJobResult result = null;

                try {
                    result = executeUpdateJob(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateMonitorAsync(UpdateMonitorRequest request) {

        return updateMonitorAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateMonitorAsync(final UpdateMonitorRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateMonitorRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateMonitorResult call() throws Exception {
                UpdateMonitorResult result = null;

                try {
                    result = executeUpdateMonitor(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateQueueAsync(UpdateQueueRequest request) {

        return updateQueueAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateQueueAsync(final UpdateQueueRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateQueueRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateQueueResult call() throws Exception {
                UpdateQueueResult result = null;

                try {
                    result = executeUpdateQueue(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateQueueEnvironmentAsync(UpdateQueueEnvironmentRequest request) {

        return updateQueueEnvironmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateQueueEnvironmentAsync(final UpdateQueueEnvironmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateQueueEnvironmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateQueueEnvironmentResult call() throws Exception {
                UpdateQueueEnvironmentResult result = null;

                try {
                    result = executeUpdateQueueEnvironment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateQueueFleetAssociationAsync(UpdateQueueFleetAssociationRequest request) {

        return updateQueueFleetAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateQueueFleetAssociationAsync(final UpdateQueueFleetAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateQueueFleetAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateQueueFleetAssociationResult call() throws Exception {
                UpdateQueueFleetAssociationResult result = null;

                try {
                    result = executeUpdateQueueFleetAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateSessionAsync(UpdateSessionRequest request) {

        return updateSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateSessionAsync(final UpdateSessionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateSessionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateSessionResult call() throws Exception {
                UpdateSessionResult result = null;

                try {
                    result = executeUpdateSession(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateStepAsync(UpdateStepRequest request) {

        return updateStepAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateStepAsync(final UpdateStepRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateStepRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateStepResult call() throws Exception {
                UpdateStepResult result = null;

                try {
                    result = executeUpdateStep(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateStorageProfileAsync(UpdateStorageProfileRequest request) {

        return updateStorageProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateStorageProfileAsync(final UpdateStorageProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateStorageProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateStorageProfileResult call() throws Exception {
                UpdateStorageProfileResult result = null;

                try {
                    result = executeUpdateStorageProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateTaskAsync(UpdateTaskRequest request) {

        return updateTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateTaskAsync(final UpdateTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateTaskResult call() throws Exception {
                UpdateTaskResult result = null;

                try {
                    result = executeUpdateTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateWorkerAsync(UpdateWorkerRequest request) {

        return updateWorkerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateWorkerAsync(final UpdateWorkerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateWorkerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateWorkerResult call() throws Exception {
                UpdateWorkerResult result = null;

                try {
                    result = executeUpdateWorker(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateWorkerScheduleAsync(UpdateWorkerScheduleRequest request) {

        return updateWorkerScheduleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateWorkerScheduleAsync(final UpdateWorkerScheduleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateWorkerScheduleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateWorkerScheduleResult call() throws Exception {
                UpdateWorkerScheduleResult result = null;

                try {
                    result = executeUpdateWorkerSchedule(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
     * asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
     * call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
     * calling this method.
     */
    @Override
    public void shutdown() {
        super.shutdown();
        executorService.shutdownNow();
    }
}