com.amazonaws.services.workspaces.AmazonWorkspacesAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-workspaces Show documentation
/*
* Copyright 2017-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.workspaces;
import static java.util.concurrent.Executors.newFixedThreadPool;
import javax.annotation.Generated;
import com.amazonaws.services.workspaces.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import java.util.concurrent.ExecutorService;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
/**
* Client for accessing Amazon WorkSpaces 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.
*
* Amazon WorkSpaces Service
*
* Amazon WorkSpaces enables you to provision virtual, cloud-based Microsoft Windows or Amazon Linux desktops for your
* users, known as WorkSpaces. WorkSpaces eliminates the need to procure and deploy hardware or install complex
* software. You can quickly add or remove users as your needs change. Users can access their virtual desktops from
* multiple devices or web browsers.
*
*
* This API Reference provides detailed information about the actions, data types, parameters, and errors of the
* WorkSpaces service. For more information about the supported Amazon Web Services Regions, endpoints, and service
* quotas of the Amazon WorkSpaces service, see WorkSpaces endpoints and quotas in the Amazon
* Web Services General Reference.
*
*
* You can also manage your WorkSpaces resources using the WorkSpaces console, Command Line Interface (CLI), and SDKs.
* For more information about administering WorkSpaces, see the Amazon WorkSpaces Administration Guide. For more
* information about using the Amazon WorkSpaces client application or web browser to access provisioned WorkSpaces, see
* the Amazon WorkSpaces User Guide. For more
* information about using the CLI to manage your WorkSpaces resources, see the WorkSpaces section of the CLI
* Reference.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonWorkspacesAsyncClient extends AmazonWorkspacesClient implements AmazonWorkspacesAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces. A credentials provider chain
* will be used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonWorkspacesAsyncClient() {
this(DefaultAWSCredentialsProviderChain.getInstance());
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces. A credentials provider chain
* will be used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon WorkSpaces (ex: proxy
* settings, retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonWorkspacesAsyncClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the specified AWS
* account credentials.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonWorkspacesAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the specified AWS
* account credentials and executor service. Default client settings will be used.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonWorkspacesAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonWorkspacesAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the specified AWS
* account credentials, executor service, and client configuration options.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonWorkspacesAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonWorkspacesAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonWorkspacesAsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the specified AWS
* account credentials provider. Default client settings will be used.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonWorkspacesAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the provided AWS
* account credentials provider and client configuration options.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonWorkspacesAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonWorkspacesAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the specified AWS
* account credentials provider and executor service. Default client settings will be used.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonWorkspacesAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonWorkspacesAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the specified AWS
* account credentials provider, executor service, and client configuration options.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonWorkspacesAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonWorkspacesAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonWorkspacesAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonWorkspacesAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
public static AmazonWorkspacesAsyncClientBuilder asyncBuilder() {
return AmazonWorkspacesAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AmazonWorkspacesAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon WorkSpaces using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AmazonWorkspacesAsyncClient(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 associateConnectionAliasAsync(AssociateConnectionAliasRequest request) {
return associateConnectionAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future associateConnectionAliasAsync(final AssociateConnectionAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AssociateConnectionAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AssociateConnectionAliasResult call() throws Exception {
AssociateConnectionAliasResult result = null;
try {
result = executeAssociateConnectionAlias(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 associateIpGroupsAsync(AssociateIpGroupsRequest request) {
return associateIpGroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future associateIpGroupsAsync(final AssociateIpGroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AssociateIpGroupsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AssociateIpGroupsResult call() throws Exception {
AssociateIpGroupsResult result = null;
try {
result = executeAssociateIpGroups(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 authorizeIpRulesAsync(AuthorizeIpRulesRequest request) {
return authorizeIpRulesAsync(request, null);
}
@Override
public java.util.concurrent.Future authorizeIpRulesAsync(final AuthorizeIpRulesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AuthorizeIpRulesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AuthorizeIpRulesResult call() throws Exception {
AuthorizeIpRulesResult result = null;
try {
result = executeAuthorizeIpRules(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 copyWorkspaceImageAsync(CopyWorkspaceImageRequest request) {
return copyWorkspaceImageAsync(request, null);
}
@Override
public java.util.concurrent.Future copyWorkspaceImageAsync(final CopyWorkspaceImageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CopyWorkspaceImageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CopyWorkspaceImageResult call() throws Exception {
CopyWorkspaceImageResult result = null;
try {
result = executeCopyWorkspaceImage(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 createConnectClientAddInAsync(CreateConnectClientAddInRequest request) {
return createConnectClientAddInAsync(request, null);
}
@Override
public java.util.concurrent.Future createConnectClientAddInAsync(final CreateConnectClientAddInRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateConnectClientAddInRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateConnectClientAddInResult call() throws Exception {
CreateConnectClientAddInResult result = null;
try {
result = executeCreateConnectClientAddIn(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 createConnectionAliasAsync(CreateConnectionAliasRequest request) {
return createConnectionAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future createConnectionAliasAsync(final CreateConnectionAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateConnectionAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateConnectionAliasResult call() throws Exception {
CreateConnectionAliasResult result = null;
try {
result = executeCreateConnectionAlias(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 createIpGroupAsync(CreateIpGroupRequest request) {
return createIpGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createIpGroupAsync(final CreateIpGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateIpGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateIpGroupResult call() throws Exception {
CreateIpGroupResult result = null;
try {
result = executeCreateIpGroup(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 createTagsAsync(CreateTagsRequest request) {
return createTagsAsync(request, null);
}
@Override
public java.util.concurrent.Future createTagsAsync(final CreateTagsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateTagsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTagsResult call() throws Exception {
CreateTagsResult result = null;
try {
result = executeCreateTags(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 createUpdatedWorkspaceImageAsync(CreateUpdatedWorkspaceImageRequest request) {
return createUpdatedWorkspaceImageAsync(request, null);
}
@Override
public java.util.concurrent.Future createUpdatedWorkspaceImageAsync(final CreateUpdatedWorkspaceImageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateUpdatedWorkspaceImageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUpdatedWorkspaceImageResult call() throws Exception {
CreateUpdatedWorkspaceImageResult result = null;
try {
result = executeCreateUpdatedWorkspaceImage(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 createWorkspaceBundleAsync(CreateWorkspaceBundleRequest request) {
return createWorkspaceBundleAsync(request, null);
}
@Override
public java.util.concurrent.Future createWorkspaceBundleAsync(final CreateWorkspaceBundleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateWorkspaceBundleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateWorkspaceBundleResult call() throws Exception {
CreateWorkspaceBundleResult result = null;
try {
result = executeCreateWorkspaceBundle(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 createWorkspacesAsync(CreateWorkspacesRequest request) {
return createWorkspacesAsync(request, null);
}
@Override
public java.util.concurrent.Future createWorkspacesAsync(final CreateWorkspacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateWorkspacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateWorkspacesResult call() throws Exception {
CreateWorkspacesResult result = null;
try {
result = executeCreateWorkspaces(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 deleteClientBrandingAsync(DeleteClientBrandingRequest request) {
return deleteClientBrandingAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteClientBrandingAsync(final DeleteClientBrandingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteClientBrandingRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteClientBrandingResult call() throws Exception {
DeleteClientBrandingResult result = null;
try {
result = executeDeleteClientBranding(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 deleteConnectClientAddInAsync(DeleteConnectClientAddInRequest request) {
return deleteConnectClientAddInAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteConnectClientAddInAsync(final DeleteConnectClientAddInRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteConnectClientAddInRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteConnectClientAddInResult call() throws Exception {
DeleteConnectClientAddInResult result = null;
try {
result = executeDeleteConnectClientAddIn(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 deleteConnectionAliasAsync(DeleteConnectionAliasRequest request) {
return deleteConnectionAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteConnectionAliasAsync(final DeleteConnectionAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteConnectionAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteConnectionAliasResult call() throws Exception {
DeleteConnectionAliasResult result = null;
try {
result = executeDeleteConnectionAlias(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 deleteIpGroupAsync(DeleteIpGroupRequest request) {
return deleteIpGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteIpGroupAsync(final DeleteIpGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteIpGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteIpGroupResult call() throws Exception {
DeleteIpGroupResult result = null;
try {
result = executeDeleteIpGroup(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 deleteTagsAsync(DeleteTagsRequest request) {
return deleteTagsAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTagsAsync(final DeleteTagsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteTagsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTagsResult call() throws Exception {
DeleteTagsResult result = null;
try {
result = executeDeleteTags(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 deleteWorkspaceBundleAsync(DeleteWorkspaceBundleRequest request) {
return deleteWorkspaceBundleAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteWorkspaceBundleAsync(final DeleteWorkspaceBundleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteWorkspaceBundleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteWorkspaceBundleResult call() throws Exception {
DeleteWorkspaceBundleResult result = null;
try {
result = executeDeleteWorkspaceBundle(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 deleteWorkspaceImageAsync(DeleteWorkspaceImageRequest request) {
return deleteWorkspaceImageAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteWorkspaceImageAsync(final DeleteWorkspaceImageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteWorkspaceImageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteWorkspaceImageResult call() throws Exception {
DeleteWorkspaceImageResult result = null;
try {
result = executeDeleteWorkspaceImage(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 deregisterWorkspaceDirectoryAsync(DeregisterWorkspaceDirectoryRequest request) {
return deregisterWorkspaceDirectoryAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterWorkspaceDirectoryAsync(final DeregisterWorkspaceDirectoryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeregisterWorkspaceDirectoryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterWorkspaceDirectoryResult call() throws Exception {
DeregisterWorkspaceDirectoryResult result = null;
try {
result = executeDeregisterWorkspaceDirectory(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 describeAccountAsync(DescribeAccountRequest request) {
return describeAccountAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAccountAsync(final DescribeAccountRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeAccountRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAccountResult call() throws Exception {
DescribeAccountResult result = null;
try {
result = executeDescribeAccount(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 describeAccountModificationsAsync(DescribeAccountModificationsRequest request) {
return describeAccountModificationsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAccountModificationsAsync(final DescribeAccountModificationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeAccountModificationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAccountModificationsResult call() throws Exception {
DescribeAccountModificationsResult result = null;
try {
result = executeDescribeAccountModifications(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 describeClientBrandingAsync(DescribeClientBrandingRequest request) {
return describeClientBrandingAsync(request, null);
}
@Override
public java.util.concurrent.Future describeClientBrandingAsync(final DescribeClientBrandingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeClientBrandingRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeClientBrandingResult call() throws Exception {
DescribeClientBrandingResult result = null;
try {
result = executeDescribeClientBranding(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 describeClientPropertiesAsync(DescribeClientPropertiesRequest request) {
return describeClientPropertiesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeClientPropertiesAsync(final DescribeClientPropertiesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeClientPropertiesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeClientPropertiesResult call() throws Exception {
DescribeClientPropertiesResult result = null;
try {
result = executeDescribeClientProperties(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 describeConnectClientAddInsAsync(DescribeConnectClientAddInsRequest request) {
return describeConnectClientAddInsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeConnectClientAddInsAsync(final DescribeConnectClientAddInsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeConnectClientAddInsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeConnectClientAddInsResult call() throws Exception {
DescribeConnectClientAddInsResult result = null;
try {
result = executeDescribeConnectClientAddIns(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 describeConnectionAliasPermissionsAsync(
DescribeConnectionAliasPermissionsRequest request) {
return describeConnectionAliasPermissionsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeConnectionAliasPermissionsAsync(
final DescribeConnectionAliasPermissionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeConnectionAliasPermissionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeConnectionAliasPermissionsResult call() throws Exception {
DescribeConnectionAliasPermissionsResult result = null;
try {
result = executeDescribeConnectionAliasPermissions(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 describeConnectionAliasesAsync(DescribeConnectionAliasesRequest request) {
return describeConnectionAliasesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeConnectionAliasesAsync(final DescribeConnectionAliasesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeConnectionAliasesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeConnectionAliasesResult call() throws Exception {
DescribeConnectionAliasesResult result = null;
try {
result = executeDescribeConnectionAliases(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 describeIpGroupsAsync(DescribeIpGroupsRequest request) {
return describeIpGroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeIpGroupsAsync(final DescribeIpGroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeIpGroupsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeIpGroupsResult call() throws Exception {
DescribeIpGroupsResult result = null;
try {
result = executeDescribeIpGroups(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 describeTagsAsync(DescribeTagsRequest request) {
return describeTagsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeTagsAsync(final DescribeTagsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeTagsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeTagsResult call() throws Exception {
DescribeTagsResult result = null;
try {
result = executeDescribeTags(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 describeWorkspaceBundlesAsync(DescribeWorkspaceBundlesRequest request) {
return describeWorkspaceBundlesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeWorkspaceBundlesAsync(final DescribeWorkspaceBundlesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeWorkspaceBundlesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeWorkspaceBundlesResult call() throws Exception {
DescribeWorkspaceBundlesResult result = null;
try {
result = executeDescribeWorkspaceBundles(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeWorkspaceBundles operation.
*
* @see #describeWorkspaceBundlesAsync(DescribeWorkspaceBundlesRequest)
*/
@Override
public java.util.concurrent.Future describeWorkspaceBundlesAsync() {
return describeWorkspaceBundlesAsync(new DescribeWorkspaceBundlesRequest());
}
/**
* Simplified method form for invoking the DescribeWorkspaceBundles operation with an AsyncHandler.
*
* @see #describeWorkspaceBundlesAsync(DescribeWorkspaceBundlesRequest, com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future describeWorkspaceBundlesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeWorkspaceBundlesAsync(new DescribeWorkspaceBundlesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeWorkspaceDirectoriesAsync(DescribeWorkspaceDirectoriesRequest request) {
return describeWorkspaceDirectoriesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeWorkspaceDirectoriesAsync(final DescribeWorkspaceDirectoriesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeWorkspaceDirectoriesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeWorkspaceDirectoriesResult call() throws Exception {
DescribeWorkspaceDirectoriesResult result = null;
try {
result = executeDescribeWorkspaceDirectories(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeWorkspaceDirectories operation.
*
* @see #describeWorkspaceDirectoriesAsync(DescribeWorkspaceDirectoriesRequest)
*/
@Override
public java.util.concurrent.Future describeWorkspaceDirectoriesAsync() {
return describeWorkspaceDirectoriesAsync(new DescribeWorkspaceDirectoriesRequest());
}
/**
* Simplified method form for invoking the DescribeWorkspaceDirectories operation with an AsyncHandler.
*
* @see #describeWorkspaceDirectoriesAsync(DescribeWorkspaceDirectoriesRequest, com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future describeWorkspaceDirectoriesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeWorkspaceDirectoriesAsync(new DescribeWorkspaceDirectoriesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeWorkspaceImagePermissionsAsync(
DescribeWorkspaceImagePermissionsRequest request) {
return describeWorkspaceImagePermissionsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeWorkspaceImagePermissionsAsync(
final DescribeWorkspaceImagePermissionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeWorkspaceImagePermissionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeWorkspaceImagePermissionsResult call() throws Exception {
DescribeWorkspaceImagePermissionsResult result = null;
try {
result = executeDescribeWorkspaceImagePermissions(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 describeWorkspaceImagesAsync(DescribeWorkspaceImagesRequest request) {
return describeWorkspaceImagesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeWorkspaceImagesAsync(final DescribeWorkspaceImagesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeWorkspaceImagesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeWorkspaceImagesResult call() throws Exception {
DescribeWorkspaceImagesResult result = null;
try {
result = executeDescribeWorkspaceImages(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 describeWorkspaceSnapshotsAsync(DescribeWorkspaceSnapshotsRequest request) {
return describeWorkspaceSnapshotsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeWorkspaceSnapshotsAsync(final DescribeWorkspaceSnapshotsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeWorkspaceSnapshotsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeWorkspaceSnapshotsResult call() throws Exception {
DescribeWorkspaceSnapshotsResult result = null;
try {
result = executeDescribeWorkspaceSnapshots(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 describeWorkspacesAsync(DescribeWorkspacesRequest request) {
return describeWorkspacesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeWorkspacesAsync(final DescribeWorkspacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeWorkspacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeWorkspacesResult call() throws Exception {
DescribeWorkspacesResult result = null;
try {
result = executeDescribeWorkspaces(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeWorkspaces operation.
*
* @see #describeWorkspacesAsync(DescribeWorkspacesRequest)
*/
@Override
public java.util.concurrent.Future describeWorkspacesAsync() {
return describeWorkspacesAsync(new DescribeWorkspacesRequest());
}
/**
* Simplified method form for invoking the DescribeWorkspaces operation with an AsyncHandler.
*
* @see #describeWorkspacesAsync(DescribeWorkspacesRequest, com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future describeWorkspacesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeWorkspacesAsync(new DescribeWorkspacesRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future describeWorkspacesConnectionStatusAsync(
DescribeWorkspacesConnectionStatusRequest request) {
return describeWorkspacesConnectionStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future describeWorkspacesConnectionStatusAsync(
final DescribeWorkspacesConnectionStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeWorkspacesConnectionStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeWorkspacesConnectionStatusResult call() throws Exception {
DescribeWorkspacesConnectionStatusResult result = null;
try {
result = executeDescribeWorkspacesConnectionStatus(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 disassociateConnectionAliasAsync(DisassociateConnectionAliasRequest request) {
return disassociateConnectionAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future disassociateConnectionAliasAsync(final DisassociateConnectionAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DisassociateConnectionAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DisassociateConnectionAliasResult call() throws Exception {
DisassociateConnectionAliasResult result = null;
try {
result = executeDisassociateConnectionAlias(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 disassociateIpGroupsAsync(DisassociateIpGroupsRequest request) {
return disassociateIpGroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future disassociateIpGroupsAsync(final DisassociateIpGroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DisassociateIpGroupsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DisassociateIpGroupsResult call() throws Exception {
DisassociateIpGroupsResult result = null;
try {
result = executeDisassociateIpGroups(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 importClientBrandingAsync(ImportClientBrandingRequest request) {
return importClientBrandingAsync(request, null);
}
@Override
public java.util.concurrent.Future importClientBrandingAsync(final ImportClientBrandingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ImportClientBrandingRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ImportClientBrandingResult call() throws Exception {
ImportClientBrandingResult result = null;
try {
result = executeImportClientBranding(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 importWorkspaceImageAsync(ImportWorkspaceImageRequest request) {
return importWorkspaceImageAsync(request, null);
}
@Override
public java.util.concurrent.Future importWorkspaceImageAsync(final ImportWorkspaceImageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ImportWorkspaceImageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ImportWorkspaceImageResult call() throws Exception {
ImportWorkspaceImageResult result = null;
try {
result = executeImportWorkspaceImage(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 listAvailableManagementCidrRangesAsync(
ListAvailableManagementCidrRangesRequest request) {
return listAvailableManagementCidrRangesAsync(request, null);
}
@Override
public java.util.concurrent.Future listAvailableManagementCidrRangesAsync(
final ListAvailableManagementCidrRangesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListAvailableManagementCidrRangesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListAvailableManagementCidrRangesResult call() throws Exception {
ListAvailableManagementCidrRangesResult result = null;
try {
result = executeListAvailableManagementCidrRanges(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 migrateWorkspaceAsync(MigrateWorkspaceRequest request) {
return migrateWorkspaceAsync(request, null);
}
@Override
public java.util.concurrent.Future migrateWorkspaceAsync(final MigrateWorkspaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final MigrateWorkspaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public MigrateWorkspaceResult call() throws Exception {
MigrateWorkspaceResult result = null;
try {
result = executeMigrateWorkspace(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 modifyAccountAsync(ModifyAccountRequest request) {
return modifyAccountAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyAccountAsync(final ModifyAccountRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ModifyAccountRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ModifyAccountResult call() throws Exception {
ModifyAccountResult result = null;
try {
result = executeModifyAccount(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 modifyClientPropertiesAsync(ModifyClientPropertiesRequest request) {
return modifyClientPropertiesAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyClientPropertiesAsync(final ModifyClientPropertiesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ModifyClientPropertiesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ModifyClientPropertiesResult call() throws Exception {
ModifyClientPropertiesResult result = null;
try {
result = executeModifyClientProperties(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 modifySelfservicePermissionsAsync(ModifySelfservicePermissionsRequest request) {
return modifySelfservicePermissionsAsync(request, null);
}
@Override
public java.util.concurrent.Future modifySelfservicePermissionsAsync(final ModifySelfservicePermissionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ModifySelfservicePermissionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ModifySelfservicePermissionsResult call() throws Exception {
ModifySelfservicePermissionsResult result = null;
try {
result = executeModifySelfservicePermissions(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 modifyWorkspaceAccessPropertiesAsync(
ModifyWorkspaceAccessPropertiesRequest request) {
return modifyWorkspaceAccessPropertiesAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyWorkspaceAccessPropertiesAsync(
final ModifyWorkspaceAccessPropertiesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ModifyWorkspaceAccessPropertiesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ModifyWorkspaceAccessPropertiesResult call() throws Exception {
ModifyWorkspaceAccessPropertiesResult result = null;
try {
result = executeModifyWorkspaceAccessProperties(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 modifyWorkspaceCreationPropertiesAsync(
ModifyWorkspaceCreationPropertiesRequest request) {
return modifyWorkspaceCreationPropertiesAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyWorkspaceCreationPropertiesAsync(
final ModifyWorkspaceCreationPropertiesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ModifyWorkspaceCreationPropertiesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ModifyWorkspaceCreationPropertiesResult call() throws Exception {
ModifyWorkspaceCreationPropertiesResult result = null;
try {
result = executeModifyWorkspaceCreationProperties(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 modifyWorkspacePropertiesAsync(ModifyWorkspacePropertiesRequest request) {
return modifyWorkspacePropertiesAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyWorkspacePropertiesAsync(final ModifyWorkspacePropertiesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ModifyWorkspacePropertiesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ModifyWorkspacePropertiesResult call() throws Exception {
ModifyWorkspacePropertiesResult result = null;
try {
result = executeModifyWorkspaceProperties(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 modifyWorkspaceStateAsync(ModifyWorkspaceStateRequest request) {
return modifyWorkspaceStateAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyWorkspaceStateAsync(final ModifyWorkspaceStateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ModifyWorkspaceStateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ModifyWorkspaceStateResult call() throws Exception {
ModifyWorkspaceStateResult result = null;
try {
result = executeModifyWorkspaceState(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 rebootWorkspacesAsync(RebootWorkspacesRequest request) {
return rebootWorkspacesAsync(request, null);
}
@Override
public java.util.concurrent.Future rebootWorkspacesAsync(final RebootWorkspacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RebootWorkspacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RebootWorkspacesResult call() throws Exception {
RebootWorkspacesResult result = null;
try {
result = executeRebootWorkspaces(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 rebuildWorkspacesAsync(RebuildWorkspacesRequest request) {
return rebuildWorkspacesAsync(request, null);
}
@Override
public java.util.concurrent.Future rebuildWorkspacesAsync(final RebuildWorkspacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RebuildWorkspacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RebuildWorkspacesResult call() throws Exception {
RebuildWorkspacesResult result = null;
try {
result = executeRebuildWorkspaces(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 registerWorkspaceDirectoryAsync(RegisterWorkspaceDirectoryRequest request) {
return registerWorkspaceDirectoryAsync(request, null);
}
@Override
public java.util.concurrent.Future registerWorkspaceDirectoryAsync(final RegisterWorkspaceDirectoryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RegisterWorkspaceDirectoryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RegisterWorkspaceDirectoryResult call() throws Exception {
RegisterWorkspaceDirectoryResult result = null;
try {
result = executeRegisterWorkspaceDirectory(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 restoreWorkspaceAsync(RestoreWorkspaceRequest request) {
return restoreWorkspaceAsync(request, null);
}
@Override
public java.util.concurrent.Future restoreWorkspaceAsync(final RestoreWorkspaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RestoreWorkspaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RestoreWorkspaceResult call() throws Exception {
RestoreWorkspaceResult result = null;
try {
result = executeRestoreWorkspace(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 revokeIpRulesAsync(RevokeIpRulesRequest request) {
return revokeIpRulesAsync(request, null);
}
@Override
public java.util.concurrent.Future revokeIpRulesAsync(final RevokeIpRulesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RevokeIpRulesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RevokeIpRulesResult call() throws Exception {
RevokeIpRulesResult result = null;
try {
result = executeRevokeIpRules(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 startWorkspacesAsync(StartWorkspacesRequest request) {
return startWorkspacesAsync(request, null);
}
@Override
public java.util.concurrent.Future startWorkspacesAsync(final StartWorkspacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final StartWorkspacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public StartWorkspacesResult call() throws Exception {
StartWorkspacesResult result = null;
try {
result = executeStartWorkspaces(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 stopWorkspacesAsync(StopWorkspacesRequest request) {
return stopWorkspacesAsync(request, null);
}
@Override
public java.util.concurrent.Future stopWorkspacesAsync(final StopWorkspacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final StopWorkspacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public StopWorkspacesResult call() throws Exception {
StopWorkspacesResult result = null;
try {
result = executeStopWorkspaces(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 terminateWorkspacesAsync(TerminateWorkspacesRequest request) {
return terminateWorkspacesAsync(request, null);
}
@Override
public java.util.concurrent.Future terminateWorkspacesAsync(final TerminateWorkspacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final TerminateWorkspacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public TerminateWorkspacesResult call() throws Exception {
TerminateWorkspacesResult result = null;
try {
result = executeTerminateWorkspaces(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 updateConnectClientAddInAsync(UpdateConnectClientAddInRequest request) {
return updateConnectClientAddInAsync(request, null);
}
@Override
public java.util.concurrent.Future updateConnectClientAddInAsync(final UpdateConnectClientAddInRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateConnectClientAddInRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateConnectClientAddInResult call() throws Exception {
UpdateConnectClientAddInResult result = null;
try {
result = executeUpdateConnectClientAddIn(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 updateConnectionAliasPermissionAsync(
UpdateConnectionAliasPermissionRequest request) {
return updateConnectionAliasPermissionAsync(request, null);
}
@Override
public java.util.concurrent.Future updateConnectionAliasPermissionAsync(
final UpdateConnectionAliasPermissionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateConnectionAliasPermissionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateConnectionAliasPermissionResult call() throws Exception {
UpdateConnectionAliasPermissionResult result = null;
try {
result = executeUpdateConnectionAliasPermission(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 updateRulesOfIpGroupAsync(UpdateRulesOfIpGroupRequest request) {
return updateRulesOfIpGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future updateRulesOfIpGroupAsync(final UpdateRulesOfIpGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateRulesOfIpGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateRulesOfIpGroupResult call() throws Exception {
UpdateRulesOfIpGroupResult result = null;
try {
result = executeUpdateRulesOfIpGroup(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 updateWorkspaceBundleAsync(UpdateWorkspaceBundleRequest request) {
return updateWorkspaceBundleAsync(request, null);
}
@Override
public java.util.concurrent.Future updateWorkspaceBundleAsync(final UpdateWorkspaceBundleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateWorkspaceBundleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateWorkspaceBundleResult call() throws Exception {
UpdateWorkspaceBundleResult result = null;
try {
result = executeUpdateWorkspaceBundle(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