com.amazonaws.services.workspaces.AmazonWorkspacesClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-workspaces Show documentation
Show all versions of aws-java-sdk-workspaces Show documentation
The AWS Java SDK for Amazon WorkSpaces module holds the client classes that are used for communicating with Amazon WorkSpaces Service
/*
* 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 org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.workspaces.AmazonWorkspacesClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.workspaces.model.*;
import com.amazonaws.services.workspaces.model.transform.*;
/**
* Client for accessing Amazon WorkSpaces. All service calls made using this client are blocking, and will not return
* until the service call 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 AmazonWorkspacesClient extends AmazonWebServiceClient implements AmazonWorkspaces {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonWorkspaces.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "workspaces";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("OperationNotSupportedException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.OperationNotSupportedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceAssociatedException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.ResourceAssociatedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.ResourceNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidParameterValuesException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.InvalidParameterValuesExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("OperationInProgressException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.OperationInProgressExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceUnavailableException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.ResourceUnavailableExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceAlreadyExistsException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.ResourceAlreadyExistsExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceCreationFailedException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.ResourceCreationFailedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceLimitExceededException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.ResourceLimitExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("UnsupportedWorkspaceConfigurationException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.UnsupportedWorkspaceConfigurationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("UnsupportedNetworkConfigurationException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.UnsupportedNetworkConfigurationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("WorkspacesDefaultRoleNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.WorkspacesDefaultRoleNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AccessDeniedException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.AccessDeniedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidResourceStateException").withExceptionUnmarshaller(
com.amazonaws.services.workspaces.model.transform.InvalidResourceStateExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.workspaces.model.AmazonWorkspacesException.class));
/**
* Constructs a new 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
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonWorkspacesClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonWorkspacesClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), configFactory.getConfig());
}
/**
* Constructs a new 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
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon WorkSpaces (ex: proxy
* settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonWorkspacesClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonWorkspacesClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on Amazon WorkSpaces using the specified AWS account
* credentials.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @deprecated use {@link AmazonWorkspacesClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AmazonWorkspacesClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
public AmazonWorkspacesClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon WorkSpaces using the specified AWS account
* credentials and client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon WorkSpaces (ex: proxy
* settings, retry counts, etc.).
* @deprecated use {@link AmazonWorkspacesClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonWorkspacesClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonWorkspacesClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
/**
* Constructs a new client to invoke service methods on Amazon WorkSpaces using the specified AWS account
* credentials provider.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @deprecated use {@link AmazonWorkspacesClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonWorkspacesClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon WorkSpaces using the specified AWS account
* credentials provider and client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon WorkSpaces (ex: proxy
* settings, retry counts, etc.).
* @deprecated use {@link AmazonWorkspacesClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonWorkspacesClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonWorkspacesClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on Amazon WorkSpaces using the specified AWS account
* credentials provider, client configuration options, and request metric collector.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon WorkSpaces (ex: proxy
* settings, retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
* @deprecated use {@link AmazonWorkspacesClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonWorkspacesClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonWorkspacesClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AmazonWorkspacesClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
public static AmazonWorkspacesClientBuilder builder() {
return AmazonWorkspacesClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon WorkSpaces using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonWorkspacesClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on Amazon WorkSpaces using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonWorkspacesClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("https://workspaces.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/workspaces/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/workspaces/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Associates the specified connection alias with the specified directory to enable cross-Region redirection. For
* more information, see Cross-Region
* Redirection for Amazon WorkSpaces.
*
*
*
* Before performing this operation, call
* DescribeConnectionAliases to make sure that the current state of the connection alias is CREATED
* .
*
*
*
* @param associateConnectionAliasRequest
* @return Result of the AssociateConnectionAlias operation returned by the service.
* @throws ResourceAssociatedException
* The resource is associated with a directory.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.AssociateConnectionAlias
* @see AWS API Documentation
*/
@Override
public AssociateConnectionAliasResult associateConnectionAlias(AssociateConnectionAliasRequest request) {
request = beforeClientExecution(request);
return executeAssociateConnectionAlias(request);
}
@SdkInternalApi
final AssociateConnectionAliasResult executeAssociateConnectionAlias(AssociateConnectionAliasRequest associateConnectionAliasRequest) {
ExecutionContext executionContext = createExecutionContext(associateConnectionAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssociateConnectionAliasRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(associateConnectionAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssociateConnectionAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new AssociateConnectionAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates the specified IP access control group with the specified directory.
*
*
* @param associateIpGroupsRequest
* @return Result of the AssociateIpGroups operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.AssociateIpGroups
* @see AWS
* API Documentation
*/
@Override
public AssociateIpGroupsResult associateIpGroups(AssociateIpGroupsRequest request) {
request = beforeClientExecution(request);
return executeAssociateIpGroups(request);
}
@SdkInternalApi
final AssociateIpGroupsResult executeAssociateIpGroups(AssociateIpGroupsRequest associateIpGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(associateIpGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssociateIpGroupsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(associateIpGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssociateIpGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AssociateIpGroupsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds one or more rules to the specified IP access control group.
*
*
* This action gives users permission to access their WorkSpaces from the CIDR address ranges specified in the
* rules.
*
*
* @param authorizeIpRulesRequest
* @return Result of the AuthorizeIpRules operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.AuthorizeIpRules
* @see AWS
* API Documentation
*/
@Override
public AuthorizeIpRulesResult authorizeIpRules(AuthorizeIpRulesRequest request) {
request = beforeClientExecution(request);
return executeAuthorizeIpRules(request);
}
@SdkInternalApi
final AuthorizeIpRulesResult executeAuthorizeIpRules(AuthorizeIpRulesRequest authorizeIpRulesRequest) {
ExecutionContext executionContext = createExecutionContext(authorizeIpRulesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AuthorizeIpRulesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(authorizeIpRulesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AuthorizeIpRules");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AuthorizeIpRulesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Copies the specified image from the specified Region to the current Region. For more information about copying
* images, see Copy a
* Custom WorkSpaces Image.
*
*
* In the China (Ningxia) Region, you can copy images only within the same Region.
*
*
* In Amazon Web Services GovCloud (US), to copy images to and from other Regions, contact Amazon Web Services
* Support.
*
*
*
* Before copying a shared image, be sure to verify that it has been shared from the correct Amazon Web Services
* account. To determine if an image has been shared and to see the ID of the Amazon Web Services account that owns
* an image, use the
* DescribeWorkSpaceImages and DescribeWorkspaceImagePermissions API operations.
*
*
*
* @param copyWorkspaceImageRequest
* @return Result of the CopyWorkspaceImage operation returned by the service.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws ResourceAlreadyExistsException
* The specified resource already exists.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceUnavailableException
* The specified resource is not available.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.CopyWorkspaceImage
* @see AWS
* API Documentation
*/
@Override
public CopyWorkspaceImageResult copyWorkspaceImage(CopyWorkspaceImageRequest request) {
request = beforeClientExecution(request);
return executeCopyWorkspaceImage(request);
}
@SdkInternalApi
final CopyWorkspaceImageResult executeCopyWorkspaceImage(CopyWorkspaceImageRequest copyWorkspaceImageRequest) {
ExecutionContext executionContext = createExecutionContext(copyWorkspaceImageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyWorkspaceImageRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(copyWorkspaceImageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopyWorkspaceImage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CopyWorkspaceImageResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a client-add-in for Amazon Connect within a directory. You can create only one Amazon Connect client
* add-in within a directory.
*
*
* This client add-in allows WorkSpaces users to seamlessly connect to Amazon Connect.
*
*
* @param createConnectClientAddInRequest
* @return Result of the CreateConnectClientAddIn operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceCreationFailedException
* The resource could not be created.
* @throws ResourceAlreadyExistsException
* The specified resource already exists.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.CreateConnectClientAddIn
* @see AWS API Documentation
*/
@Override
public CreateConnectClientAddInResult createConnectClientAddIn(CreateConnectClientAddInRequest request) {
request = beforeClientExecution(request);
return executeCreateConnectClientAddIn(request);
}
@SdkInternalApi
final CreateConnectClientAddInResult executeCreateConnectClientAddIn(CreateConnectClientAddInRequest createConnectClientAddInRequest) {
ExecutionContext executionContext = createExecutionContext(createConnectClientAddInRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateConnectClientAddInRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createConnectClientAddInRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateConnectClientAddIn");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateConnectClientAddInResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates the specified connection alias for use with cross-Region redirection. For more information, see Cross-Region
* Redirection for Amazon WorkSpaces.
*
*
* @param createConnectionAliasRequest
* @return Result of the CreateConnectionAlias operation returned by the service.
* @throws ResourceAlreadyExistsException
* The specified resource already exists.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.CreateConnectionAlias
* @see AWS API Documentation
*/
@Override
public CreateConnectionAliasResult createConnectionAlias(CreateConnectionAliasRequest request) {
request = beforeClientExecution(request);
return executeCreateConnectionAlias(request);
}
@SdkInternalApi
final CreateConnectionAliasResult executeCreateConnectionAlias(CreateConnectionAliasRequest createConnectionAliasRequest) {
ExecutionContext executionContext = createExecutionContext(createConnectionAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateConnectionAliasRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createConnectionAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateConnectionAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateConnectionAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an IP access control group.
*
*
* An IP access control group provides you with the ability to control the IP addresses from which users are allowed
* to access their WorkSpaces. To specify the CIDR address ranges, add rules to your IP access control group and
* then associate the group with your directory. You can add rules when you create the group or at any time using
* AuthorizeIpRules.
*
*
* There is a default IP access control group associated with your directory. If you don't associate an IP access
* control group with your directory, the default group is used. The default group includes a default rule that
* allows users to access their WorkSpaces from anywhere. You cannot modify the default IP access control group for
* your directory.
*
*
* @param createIpGroupRequest
* @return Result of the CreateIpGroup operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws ResourceAlreadyExistsException
* The specified resource already exists.
* @throws ResourceCreationFailedException
* The resource could not be created.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.CreateIpGroup
* @see AWS API
* Documentation
*/
@Override
public CreateIpGroupResult createIpGroup(CreateIpGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateIpGroup(request);
}
@SdkInternalApi
final CreateIpGroupResult executeCreateIpGroup(CreateIpGroupRequest createIpGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createIpGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateIpGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createIpGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateIpGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateIpGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a Standby WorkSpace in a secondary region.
*
*
* @param createStandbyWorkspacesRequest
* @return Result of the CreateStandbyWorkspaces operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @sample AmazonWorkspaces.CreateStandbyWorkspaces
* @see AWS API Documentation
*/
@Override
public CreateStandbyWorkspacesResult createStandbyWorkspaces(CreateStandbyWorkspacesRequest request) {
request = beforeClientExecution(request);
return executeCreateStandbyWorkspaces(request);
}
@SdkInternalApi
final CreateStandbyWorkspacesResult executeCreateStandbyWorkspaces(CreateStandbyWorkspacesRequest createStandbyWorkspacesRequest) {
ExecutionContext executionContext = createExecutionContext(createStandbyWorkspacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateStandbyWorkspacesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createStandbyWorkspacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateStandbyWorkspaces");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateStandbyWorkspacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates the specified tags for the specified WorkSpaces resource.
*
*
* @param createTagsRequest
* @return Result of the CreateTags operation returned by the service.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @sample AmazonWorkspaces.CreateTags
* @see AWS API
* Documentation
*/
@Override
public CreateTagsResult createTags(CreateTagsRequest request) {
request = beforeClientExecution(request);
return executeCreateTags(request);
}
@SdkInternalApi
final CreateTagsResult executeCreateTags(CreateTagsRequest createTagsRequest) {
ExecutionContext executionContext = createExecutionContext(createTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateTagsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateTagsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new updated WorkSpace image based on the specified source image. The new updated WorkSpace image has
* the latest drivers and other updates required by the Amazon WorkSpaces components.
*
*
* To determine which WorkSpace images need to be updated with the latest Amazon WorkSpaces requirements, use
* DescribeWorkspaceImages.
*
*
*
* -
*
* Only Windows 10, Windows Sever 2016, and Windows Server 2019 WorkSpace images can be programmatically updated at
* this time.
*
*
* -
*
* Microsoft Windows updates and other application updates are not included in the update process.
*
*
* -
*
* The source WorkSpace image is not deleted. You can delete the source image after you've verified your new updated
* image and created a new bundle.
*
*
*
*
*
* @param createUpdatedWorkspaceImageRequest
* @return Result of the CreateUpdatedWorkspaceImage operation returned by the service.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws ResourceAlreadyExistsException
* The specified resource already exists.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.CreateUpdatedWorkspaceImage
* @see AWS API Documentation
*/
@Override
public CreateUpdatedWorkspaceImageResult createUpdatedWorkspaceImage(CreateUpdatedWorkspaceImageRequest request) {
request = beforeClientExecution(request);
return executeCreateUpdatedWorkspaceImage(request);
}
@SdkInternalApi
final CreateUpdatedWorkspaceImageResult executeCreateUpdatedWorkspaceImage(CreateUpdatedWorkspaceImageRequest createUpdatedWorkspaceImageRequest) {
ExecutionContext executionContext = createExecutionContext(createUpdatedWorkspaceImageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateUpdatedWorkspaceImageRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createUpdatedWorkspaceImageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateUpdatedWorkspaceImage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateUpdatedWorkspaceImageResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates the specified WorkSpace bundle. For more information about creating WorkSpace bundles, see Create a Custom
* WorkSpaces Image and Bundle.
*
*
* @param createWorkspaceBundleRequest
* @return Result of the CreateWorkspaceBundle operation returned by the service.
* @throws ResourceUnavailableException
* The specified resource is not available.
* @throws ResourceAlreadyExistsException
* The specified resource already exists.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.CreateWorkspaceBundle
* @see AWS API Documentation
*/
@Override
public CreateWorkspaceBundleResult createWorkspaceBundle(CreateWorkspaceBundleRequest request) {
request = beforeClientExecution(request);
return executeCreateWorkspaceBundle(request);
}
@SdkInternalApi
final CreateWorkspaceBundleResult executeCreateWorkspaceBundle(CreateWorkspaceBundleRequest createWorkspaceBundleRequest) {
ExecutionContext executionContext = createExecutionContext(createWorkspaceBundleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateWorkspaceBundleRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createWorkspaceBundleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateWorkspaceBundle");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateWorkspaceBundleResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new WorkSpace image from an existing WorkSpace.
*
*
* @param createWorkspaceImageRequest
* @return Result of the CreateWorkspaceImage operation returned by the service.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws ResourceAlreadyExistsException
* The specified resource already exists.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.CreateWorkspaceImage
* @see AWS API Documentation
*/
@Override
public CreateWorkspaceImageResult createWorkspaceImage(CreateWorkspaceImageRequest request) {
request = beforeClientExecution(request);
return executeCreateWorkspaceImage(request);
}
@SdkInternalApi
final CreateWorkspaceImageResult executeCreateWorkspaceImage(CreateWorkspaceImageRequest createWorkspaceImageRequest) {
ExecutionContext executionContext = createExecutionContext(createWorkspaceImageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateWorkspaceImageRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createWorkspaceImageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateWorkspaceImage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateWorkspaceImageResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates one or more WorkSpaces.
*
*
* This operation is asynchronous and returns before the WorkSpaces are created.
*
*
*
* The MANUAL running mode value is only supported by Amazon WorkSpaces Core. Contact your account team
* to be allow-listed to use this value. For more information, see Amazon WorkSpaces Core.
*
*
*
* @param createWorkspacesRequest
* @return Result of the CreateWorkspaces operation returned by the service.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.CreateWorkspaces
* @see AWS
* API Documentation
*/
@Override
public CreateWorkspacesResult createWorkspaces(CreateWorkspacesRequest request) {
request = beforeClientExecution(request);
return executeCreateWorkspaces(request);
}
@SdkInternalApi
final CreateWorkspacesResult executeCreateWorkspaces(CreateWorkspacesRequest createWorkspacesRequest) {
ExecutionContext executionContext = createExecutionContext(createWorkspacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateWorkspacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createWorkspacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateWorkspaces");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateWorkspacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes customized client branding. Client branding allows you to customize your WorkSpace's client login portal.
* You can tailor your login portal company logo, the support email address, support link, link to reset password,
* and a custom message for users trying to sign in.
*
*
* After you delete your customized client branding, your login portal reverts to the default client branding.
*
*
* @param deleteClientBrandingRequest
* @return Result of the DeleteClientBranding operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DeleteClientBranding
* @see AWS API Documentation
*/
@Override
public DeleteClientBrandingResult deleteClientBranding(DeleteClientBrandingRequest request) {
request = beforeClientExecution(request);
return executeDeleteClientBranding(request);
}
@SdkInternalApi
final DeleteClientBrandingResult executeDeleteClientBranding(DeleteClientBrandingRequest deleteClientBrandingRequest) {
ExecutionContext executionContext = createExecutionContext(deleteClientBrandingRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteClientBrandingRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteClientBrandingRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteClientBranding");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteClientBrandingResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a client-add-in for Amazon Connect that is configured within a directory.
*
*
* @param deleteConnectClientAddInRequest
* @return Result of the DeleteConnectClientAddIn operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DeleteConnectClientAddIn
* @see AWS API Documentation
*/
@Override
public DeleteConnectClientAddInResult deleteConnectClientAddIn(DeleteConnectClientAddInRequest request) {
request = beforeClientExecution(request);
return executeDeleteConnectClientAddIn(request);
}
@SdkInternalApi
final DeleteConnectClientAddInResult executeDeleteConnectClientAddIn(DeleteConnectClientAddInRequest deleteConnectClientAddInRequest) {
ExecutionContext executionContext = createExecutionContext(deleteConnectClientAddInRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteConnectClientAddInRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteConnectClientAddInRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteConnectClientAddIn");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteConnectClientAddInResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified connection alias. For more information, see Cross-Region
* Redirection for Amazon WorkSpaces.
*
*
*
* If you will no longer be using a fully qualified domain name (FQDN) as the registration code for your
* WorkSpaces users, you must take certain precautions to prevent potential security issues. For more
* information, see Security Considerations if You Stop Using Cross-Region Redirection.
*
*
*
* To delete a connection alias that has been shared, the shared account must first disassociate the connection
* alias from any directories it has been associated with. Then you must unshare the connection alias from the
* account it has been shared with. You can delete a connection alias only after it is no longer shared with any
* accounts or associated with any directories.
*
*
*
* @param deleteConnectionAliasRequest
* @return Result of the DeleteConnectionAlias operation returned by the service.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceAssociatedException
* The resource is associated with a directory.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.DeleteConnectionAlias
* @see AWS API Documentation
*/
@Override
public DeleteConnectionAliasResult deleteConnectionAlias(DeleteConnectionAliasRequest request) {
request = beforeClientExecution(request);
return executeDeleteConnectionAlias(request);
}
@SdkInternalApi
final DeleteConnectionAliasResult executeDeleteConnectionAlias(DeleteConnectionAliasRequest deleteConnectionAliasRequest) {
ExecutionContext executionContext = createExecutionContext(deleteConnectionAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteConnectionAliasRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteConnectionAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteConnectionAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteConnectionAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified IP access control group.
*
*
* You cannot delete an IP access control group that is associated with a directory.
*
*
* @param deleteIpGroupRequest
* @return Result of the DeleteIpGroup operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceAssociatedException
* The resource is associated with a directory.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DeleteIpGroup
* @see AWS API
* Documentation
*/
@Override
public DeleteIpGroupResult deleteIpGroup(DeleteIpGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteIpGroup(request);
}
@SdkInternalApi
final DeleteIpGroupResult executeDeleteIpGroup(DeleteIpGroupRequest deleteIpGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteIpGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteIpGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteIpGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteIpGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteIpGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified tags from the specified WorkSpaces resource.
*
*
* @param deleteTagsRequest
* @return Result of the DeleteTags operation returned by the service.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.DeleteTags
* @see AWS API
* Documentation
*/
@Override
public DeleteTagsResult deleteTags(DeleteTagsRequest request) {
request = beforeClientExecution(request);
return executeDeleteTags(request);
}
@SdkInternalApi
final DeleteTagsResult executeDeleteTags(DeleteTagsRequest deleteTagsRequest) {
ExecutionContext executionContext = createExecutionContext(deleteTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteTagsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteTagsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified WorkSpace bundle. For more information about deleting WorkSpace bundles, see Delete a Custom WorkSpaces
* Bundle or Image.
*
*
* @param deleteWorkspaceBundleRequest
* @return Result of the DeleteWorkspaceBundle operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceAssociatedException
* The resource is associated with a directory.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DeleteWorkspaceBundle
* @see AWS API Documentation
*/
@Override
public DeleteWorkspaceBundleResult deleteWorkspaceBundle(DeleteWorkspaceBundleRequest request) {
request = beforeClientExecution(request);
return executeDeleteWorkspaceBundle(request);
}
@SdkInternalApi
final DeleteWorkspaceBundleResult executeDeleteWorkspaceBundle(DeleteWorkspaceBundleRequest deleteWorkspaceBundleRequest) {
ExecutionContext executionContext = createExecutionContext(deleteWorkspaceBundleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteWorkspaceBundleRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteWorkspaceBundleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteWorkspaceBundle");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteWorkspaceBundleResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified image from your account. To delete an image, you must first delete any bundles that are
* associated with the image and unshare the image if it is shared with other accounts.
*
*
* @param deleteWorkspaceImageRequest
* @return Result of the DeleteWorkspaceImage operation returned by the service.
* @throws ResourceAssociatedException
* The resource is associated with a directory.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DeleteWorkspaceImage
* @see AWS API Documentation
*/
@Override
public DeleteWorkspaceImageResult deleteWorkspaceImage(DeleteWorkspaceImageRequest request) {
request = beforeClientExecution(request);
return executeDeleteWorkspaceImage(request);
}
@SdkInternalApi
final DeleteWorkspaceImageResult executeDeleteWorkspaceImage(DeleteWorkspaceImageRequest deleteWorkspaceImageRequest) {
ExecutionContext executionContext = createExecutionContext(deleteWorkspaceImageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteWorkspaceImageRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteWorkspaceImageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteWorkspaceImage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteWorkspaceImageResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deregisters the specified directory. This operation is asynchronous and returns before the WorkSpace directory is
* deregistered. If any WorkSpaces are registered to this directory, you must remove them before you can deregister
* the directory.
*
*
*
* Simple AD and AD Connector are made available to you free of charge to use with WorkSpaces. If there are no
* WorkSpaces being used with your Simple AD or AD Connector directory for 30 consecutive days, this directory will
* be automatically deregistered for use with Amazon WorkSpaces, and you will be charged for this directory as per
* the Directory Service pricing terms.
*
*
* To delete empty directories, see Delete the
* Directory for Your WorkSpaces. If you delete your Simple AD or AD Connector directory, you can always create
* a new one when you want to start using WorkSpaces again.
*
*
*
* @param deregisterWorkspaceDirectoryRequest
* @return Result of the DeregisterWorkspaceDirectory operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @sample AmazonWorkspaces.DeregisterWorkspaceDirectory
* @see AWS API Documentation
*/
@Override
public DeregisterWorkspaceDirectoryResult deregisterWorkspaceDirectory(DeregisterWorkspaceDirectoryRequest request) {
request = beforeClientExecution(request);
return executeDeregisterWorkspaceDirectory(request);
}
@SdkInternalApi
final DeregisterWorkspaceDirectoryResult executeDeregisterWorkspaceDirectory(DeregisterWorkspaceDirectoryRequest deregisterWorkspaceDirectoryRequest) {
ExecutionContext executionContext = createExecutionContext(deregisterWorkspaceDirectoryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeregisterWorkspaceDirectoryRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deregisterWorkspaceDirectoryRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeregisterWorkspaceDirectory");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeregisterWorkspaceDirectoryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list that describes the configuration of Bring Your Own License (BYOL) for the specified account.
*
*
* @param describeAccountRequest
* @return Result of the DescribeAccount operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DescribeAccount
* @see AWS API
* Documentation
*/
@Override
public DescribeAccountResult describeAccount(DescribeAccountRequest request) {
request = beforeClientExecution(request);
return executeDescribeAccount(request);
}
@SdkInternalApi
final DescribeAccountResult executeDescribeAccount(DescribeAccountRequest describeAccountRequest) {
ExecutionContext executionContext = createExecutionContext(describeAccountRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAccountRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeAccountRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAccount");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeAccountResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list that describes modifications to the configuration of Bring Your Own License (BYOL) for the
* specified account.
*
*
* @param describeAccountModificationsRequest
* @return Result of the DescribeAccountModifications operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DescribeAccountModifications
* @see AWS API Documentation
*/
@Override
public DescribeAccountModificationsResult describeAccountModifications(DescribeAccountModificationsRequest request) {
request = beforeClientExecution(request);
return executeDescribeAccountModifications(request);
}
@SdkInternalApi
final DescribeAccountModificationsResult executeDescribeAccountModifications(DescribeAccountModificationsRequest describeAccountModificationsRequest) {
ExecutionContext executionContext = createExecutionContext(describeAccountModificationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAccountModificationsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeAccountModificationsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAccountModifications");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeAccountModificationsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the specified client branding. Client branding allows you to customize the log in page of various
* device types for your users. You can add your company logo, the support email address, support link, link to
* reset password, and a custom message for users trying to sign in.
*
*
*
* Only device types that have branding information configured will be shown in the response.
*
*
*
* @param describeClientBrandingRequest
* @return Result of the DescribeClientBranding operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DescribeClientBranding
* @see AWS API Documentation
*/
@Override
public DescribeClientBrandingResult describeClientBranding(DescribeClientBrandingRequest request) {
request = beforeClientExecution(request);
return executeDescribeClientBranding(request);
}
@SdkInternalApi
final DescribeClientBrandingResult executeDescribeClientBranding(DescribeClientBrandingRequest describeClientBrandingRequest) {
ExecutionContext executionContext = createExecutionContext(describeClientBrandingRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeClientBrandingRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeClientBrandingRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeClientBranding");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeClientBrandingResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list that describes one or more specified Amazon WorkSpaces clients.
*
*
* @param describeClientPropertiesRequest
* @return Result of the DescribeClientProperties operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DescribeClientProperties
* @see AWS API Documentation
*/
@Override
public DescribeClientPropertiesResult describeClientProperties(DescribeClientPropertiesRequest request) {
request = beforeClientExecution(request);
return executeDescribeClientProperties(request);
}
@SdkInternalApi
final DescribeClientPropertiesResult executeDescribeClientProperties(DescribeClientPropertiesRequest describeClientPropertiesRequest) {
ExecutionContext executionContext = createExecutionContext(describeClientPropertiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeClientPropertiesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeClientPropertiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeClientProperties");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeClientPropertiesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list of Amazon Connect client add-ins that have been created.
*
*
* @param describeConnectClientAddInsRequest
* @return Result of the DescribeConnectClientAddIns operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DescribeConnectClientAddIns
* @see AWS API Documentation
*/
@Override
public DescribeConnectClientAddInsResult describeConnectClientAddIns(DescribeConnectClientAddInsRequest request) {
request = beforeClientExecution(request);
return executeDescribeConnectClientAddIns(request);
}
@SdkInternalApi
final DescribeConnectClientAddInsResult executeDescribeConnectClientAddIns(DescribeConnectClientAddInsRequest describeConnectClientAddInsRequest) {
ExecutionContext executionContext = createExecutionContext(describeConnectClientAddInsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeConnectClientAddInsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeConnectClientAddInsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeConnectClientAddIns");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeConnectClientAddInsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the permissions that the owner of a connection alias has granted to another Amazon Web Services account
* for the specified connection alias. For more information, see Cross-Region
* Redirection for Amazon WorkSpaces.
*
*
* @param describeConnectionAliasPermissionsRequest
* @return Result of the DescribeConnectionAliasPermissions operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.DescribeConnectionAliasPermissions
* @see AWS API Documentation
*/
@Override
public DescribeConnectionAliasPermissionsResult describeConnectionAliasPermissions(DescribeConnectionAliasPermissionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeConnectionAliasPermissions(request);
}
@SdkInternalApi
final DescribeConnectionAliasPermissionsResult executeDescribeConnectionAliasPermissions(
DescribeConnectionAliasPermissionsRequest describeConnectionAliasPermissionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeConnectionAliasPermissionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeConnectionAliasPermissionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeConnectionAliasPermissionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeConnectionAliasPermissions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeConnectionAliasPermissionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list that describes the connection aliases used for cross-Region redirection. For more information,
* see
* Cross-Region Redirection for Amazon WorkSpaces.
*
*
* @param describeConnectionAliasesRequest
* @return Result of the DescribeConnectionAliases operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.DescribeConnectionAliases
* @see AWS API Documentation
*/
@Override
public DescribeConnectionAliasesResult describeConnectionAliases(DescribeConnectionAliasesRequest request) {
request = beforeClientExecution(request);
return executeDescribeConnectionAliases(request);
}
@SdkInternalApi
final DescribeConnectionAliasesResult executeDescribeConnectionAliases(DescribeConnectionAliasesRequest describeConnectionAliasesRequest) {
ExecutionContext executionContext = createExecutionContext(describeConnectionAliasesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeConnectionAliasesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeConnectionAliasesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeConnectionAliases");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeConnectionAliasesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes one or more of your IP access control groups.
*
*
* @param describeIpGroupsRequest
* @return Result of the DescribeIpGroups operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DescribeIpGroups
* @see AWS
* API Documentation
*/
@Override
public DescribeIpGroupsResult describeIpGroups(DescribeIpGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeIpGroups(request);
}
@SdkInternalApi
final DescribeIpGroupsResult executeDescribeIpGroups(DescribeIpGroupsRequest describeIpGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeIpGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeIpGroupsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeIpGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeIpGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeIpGroupsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the specified tags for the specified WorkSpaces resource.
*
*
* @param describeTagsRequest
* @return Result of the DescribeTags operation returned by the service.
* @throws ResourceNotFoundException
* The resource could not be found.
* @sample AmazonWorkspaces.DescribeTags
* @see AWS API
* Documentation
*/
@Override
public DescribeTagsResult describeTags(DescribeTagsRequest request) {
request = beforeClientExecution(request);
return executeDescribeTags(request);
}
@SdkInternalApi
final DescribeTagsResult executeDescribeTags(DescribeTagsRequest describeTagsRequest) {
ExecutionContext executionContext = createExecutionContext(describeTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeTagsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeTagsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list that describes the available WorkSpace bundles.
*
*
* You can filter the results using either bundle ID or owner, but not both.
*
*
* @param describeWorkspaceBundlesRequest
* @return Result of the DescribeWorkspaceBundles operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.DescribeWorkspaceBundles
* @see AWS API Documentation
*/
@Override
public DescribeWorkspaceBundlesResult describeWorkspaceBundles(DescribeWorkspaceBundlesRequest request) {
request = beforeClientExecution(request);
return executeDescribeWorkspaceBundles(request);
}
@SdkInternalApi
final DescribeWorkspaceBundlesResult executeDescribeWorkspaceBundles(DescribeWorkspaceBundlesRequest describeWorkspaceBundlesRequest) {
ExecutionContext executionContext = createExecutionContext(describeWorkspaceBundlesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWorkspaceBundlesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeWorkspaceBundlesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWorkspaceBundles");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWorkspaceBundlesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeWorkspaceBundlesResult describeWorkspaceBundles() {
return describeWorkspaceBundles(new DescribeWorkspaceBundlesRequest());
}
/**
*
* Describes the available directories that are registered with Amazon WorkSpaces.
*
*
* @param describeWorkspaceDirectoriesRequest
* @return Result of the DescribeWorkspaceDirectories operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.DescribeWorkspaceDirectories
* @see AWS API Documentation
*/
@Override
public DescribeWorkspaceDirectoriesResult describeWorkspaceDirectories(DescribeWorkspaceDirectoriesRequest request) {
request = beforeClientExecution(request);
return executeDescribeWorkspaceDirectories(request);
}
@SdkInternalApi
final DescribeWorkspaceDirectoriesResult executeDescribeWorkspaceDirectories(DescribeWorkspaceDirectoriesRequest describeWorkspaceDirectoriesRequest) {
ExecutionContext executionContext = createExecutionContext(describeWorkspaceDirectoriesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWorkspaceDirectoriesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeWorkspaceDirectoriesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWorkspaceDirectories");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWorkspaceDirectoriesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeWorkspaceDirectoriesResult describeWorkspaceDirectories() {
return describeWorkspaceDirectories(new DescribeWorkspaceDirectoriesRequest());
}
/**
*
* Describes the permissions that the owner of an image has granted to other Amazon Web Services accounts for an
* image.
*
*
* @param describeWorkspaceImagePermissionsRequest
* @return Result of the DescribeWorkspaceImagePermissions operation returned by the service.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.DescribeWorkspaceImagePermissions
* @see AWS API Documentation
*/
@Override
public DescribeWorkspaceImagePermissionsResult describeWorkspaceImagePermissions(DescribeWorkspaceImagePermissionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeWorkspaceImagePermissions(request);
}
@SdkInternalApi
final DescribeWorkspaceImagePermissionsResult executeDescribeWorkspaceImagePermissions(
DescribeWorkspaceImagePermissionsRequest describeWorkspaceImagePermissionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeWorkspaceImagePermissionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWorkspaceImagePermissionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeWorkspaceImagePermissionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWorkspaceImagePermissions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWorkspaceImagePermissionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list that describes one or more specified images, if the image identifiers are provided. Otherwise,
* all images in the account are described.
*
*
* @param describeWorkspaceImagesRequest
* @return Result of the DescribeWorkspaceImages operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DescribeWorkspaceImages
* @see AWS API Documentation
*/
@Override
public DescribeWorkspaceImagesResult describeWorkspaceImages(DescribeWorkspaceImagesRequest request) {
request = beforeClientExecution(request);
return executeDescribeWorkspaceImages(request);
}
@SdkInternalApi
final DescribeWorkspaceImagesResult executeDescribeWorkspaceImages(DescribeWorkspaceImagesRequest describeWorkspaceImagesRequest) {
ExecutionContext executionContext = createExecutionContext(describeWorkspaceImagesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWorkspaceImagesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeWorkspaceImagesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWorkspaceImages");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWorkspaceImagesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the snapshots for the specified WorkSpace.
*
*
* @param describeWorkspaceSnapshotsRequest
* @return Result of the DescribeWorkspaceSnapshots operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DescribeWorkspaceSnapshots
* @see AWS API Documentation
*/
@Override
public DescribeWorkspaceSnapshotsResult describeWorkspaceSnapshots(DescribeWorkspaceSnapshotsRequest request) {
request = beforeClientExecution(request);
return executeDescribeWorkspaceSnapshots(request);
}
@SdkInternalApi
final DescribeWorkspaceSnapshotsResult executeDescribeWorkspaceSnapshots(DescribeWorkspaceSnapshotsRequest describeWorkspaceSnapshotsRequest) {
ExecutionContext executionContext = createExecutionContext(describeWorkspaceSnapshotsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWorkspaceSnapshotsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeWorkspaceSnapshotsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWorkspaceSnapshots");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWorkspaceSnapshotsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the specified WorkSpaces.
*
*
* You can filter the results by using the bundle identifier, directory identifier, or owner, but you can specify
* only one filter at a time.
*
*
* @param describeWorkspacesRequest
* @return Result of the DescribeWorkspaces operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceUnavailableException
* The specified resource is not available.
* @sample AmazonWorkspaces.DescribeWorkspaces
* @see AWS
* API Documentation
*/
@Override
public DescribeWorkspacesResult describeWorkspaces(DescribeWorkspacesRequest request) {
request = beforeClientExecution(request);
return executeDescribeWorkspaces(request);
}
@SdkInternalApi
final DescribeWorkspacesResult executeDescribeWorkspaces(DescribeWorkspacesRequest describeWorkspacesRequest) {
ExecutionContext executionContext = createExecutionContext(describeWorkspacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWorkspacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeWorkspacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWorkspaces");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeWorkspacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeWorkspacesResult describeWorkspaces() {
return describeWorkspaces(new DescribeWorkspacesRequest());
}
/**
*
* Describes the connection status of the specified WorkSpaces.
*
*
* @param describeWorkspacesConnectionStatusRequest
* @return Result of the DescribeWorkspacesConnectionStatus operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.DescribeWorkspacesConnectionStatus
* @see AWS API Documentation
*/
@Override
public DescribeWorkspacesConnectionStatusResult describeWorkspacesConnectionStatus(DescribeWorkspacesConnectionStatusRequest request) {
request = beforeClientExecution(request);
return executeDescribeWorkspacesConnectionStatus(request);
}
@SdkInternalApi
final DescribeWorkspacesConnectionStatusResult executeDescribeWorkspacesConnectionStatus(
DescribeWorkspacesConnectionStatusRequest describeWorkspacesConnectionStatusRequest) {
ExecutionContext executionContext = createExecutionContext(describeWorkspacesConnectionStatusRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWorkspacesConnectionStatusRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeWorkspacesConnectionStatusRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWorkspacesConnectionStatus");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWorkspacesConnectionStatusResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disassociates a connection alias from a directory. Disassociating a connection alias disables cross-Region
* redirection between two directories in different Regions. For more information, see Cross-Region
* Redirection for Amazon WorkSpaces.
*
*
*
* Before performing this operation, call
* DescribeConnectionAliases to make sure that the current state of the connection alias is CREATED
* .
*
*
*
* @param disassociateConnectionAliasRequest
* @return Result of the DisassociateConnectionAlias operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.DisassociateConnectionAlias
* @see AWS API Documentation
*/
@Override
public DisassociateConnectionAliasResult disassociateConnectionAlias(DisassociateConnectionAliasRequest request) {
request = beforeClientExecution(request);
return executeDisassociateConnectionAlias(request);
}
@SdkInternalApi
final DisassociateConnectionAliasResult executeDisassociateConnectionAlias(DisassociateConnectionAliasRequest disassociateConnectionAliasRequest) {
ExecutionContext executionContext = createExecutionContext(disassociateConnectionAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisassociateConnectionAliasRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(disassociateConnectionAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisassociateConnectionAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DisassociateConnectionAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disassociates the specified IP access control group from the specified directory.
*
*
* @param disassociateIpGroupsRequest
* @return Result of the DisassociateIpGroups operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.DisassociateIpGroups
* @see AWS API Documentation
*/
@Override
public DisassociateIpGroupsResult disassociateIpGroups(DisassociateIpGroupsRequest request) {
request = beforeClientExecution(request);
return executeDisassociateIpGroups(request);
}
@SdkInternalApi
final DisassociateIpGroupsResult executeDisassociateIpGroups(DisassociateIpGroupsRequest disassociateIpGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(disassociateIpGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisassociateIpGroupsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(disassociateIpGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisassociateIpGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DisassociateIpGroupsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Imports client branding. Client branding allows you to customize your WorkSpace's client login portal. You can
* tailor your login portal company logo, the support email address, support link, link to reset password, and a
* custom message for users trying to sign in.
*
*
* After you import client branding, the default branding experience for the specified platform type is replaced
* with the imported experience
*
*
*
* -
*
* You must specify at least one platform type when importing client branding.
*
*
* -
*
* You can import up to 6 MB of data with each request. If your request exceeds this limit, you can import client
* branding for different platform types using separate requests.
*
*
* -
*
* In each platform type, the SupportEmail and SupportLink parameters are mutually
* exclusive. You can specify only one parameter for each platform type, but not both.
*
*
* -
*
* Imported data can take up to a minute to appear in the WorkSpaces client.
*
*
*
*
*
* @param importClientBrandingRequest
* @return Result of the ImportClientBranding operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.ImportClientBranding
* @see AWS API Documentation
*/
@Override
public ImportClientBrandingResult importClientBranding(ImportClientBrandingRequest request) {
request = beforeClientExecution(request);
return executeImportClientBranding(request);
}
@SdkInternalApi
final ImportClientBrandingResult executeImportClientBranding(ImportClientBrandingRequest importClientBrandingRequest) {
ExecutionContext executionContext = createExecutionContext(importClientBrandingRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ImportClientBrandingRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(importClientBrandingRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ImportClientBranding");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ImportClientBrandingResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Imports the specified Windows 10 Bring Your Own License (BYOL) or Windows Server 2016 BYOL image into Amazon
* WorkSpaces. The image must be an already licensed Amazon EC2 image that is in your Amazon Web Services account,
* and you must own the image. For more information about creating BYOL images, see Bring Your Own Windows
* Desktop Licenses.
*
*
* @param importWorkspaceImageRequest
* @return Result of the ImportWorkspaceImage operation returned by the service.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws ResourceAlreadyExistsException
* The specified resource already exists.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @sample AmazonWorkspaces.ImportWorkspaceImage
* @see AWS API Documentation
*/
@Override
public ImportWorkspaceImageResult importWorkspaceImage(ImportWorkspaceImageRequest request) {
request = beforeClientExecution(request);
return executeImportWorkspaceImage(request);
}
@SdkInternalApi
final ImportWorkspaceImageResult executeImportWorkspaceImage(ImportWorkspaceImageRequest importWorkspaceImageRequest) {
ExecutionContext executionContext = createExecutionContext(importWorkspaceImageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ImportWorkspaceImageRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(importWorkspaceImageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ImportWorkspaceImage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ImportWorkspaceImageResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list of IP address ranges, specified as IPv4 CIDR blocks, that you can use for the network management
* interface when you enable Bring Your Own License (BYOL).
*
*
* This operation can be run only by Amazon Web Services accounts that are enabled for BYOL. If your account isn't
* enabled for BYOL, you'll receive an AccessDeniedException error.
*
*
* The management network interface is connected to a secure Amazon WorkSpaces management network. It is used for
* interactive streaming of the WorkSpace desktop to Amazon WorkSpaces clients, and to allow Amazon WorkSpaces to
* manage the WorkSpace.
*
*
* @param listAvailableManagementCidrRangesRequest
* @return Result of the ListAvailableManagementCidrRanges operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.ListAvailableManagementCidrRanges
* @see AWS API Documentation
*/
@Override
public ListAvailableManagementCidrRangesResult listAvailableManagementCidrRanges(ListAvailableManagementCidrRangesRequest request) {
request = beforeClientExecution(request);
return executeListAvailableManagementCidrRanges(request);
}
@SdkInternalApi
final ListAvailableManagementCidrRangesResult executeListAvailableManagementCidrRanges(
ListAvailableManagementCidrRangesRequest listAvailableManagementCidrRangesRequest) {
ExecutionContext executionContext = createExecutionContext(listAvailableManagementCidrRangesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAvailableManagementCidrRangesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listAvailableManagementCidrRangesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListAvailableManagementCidrRanges");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListAvailableManagementCidrRangesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Migrates a WorkSpace from one operating system or bundle type to another, while retaining the data on the user
* volume.
*
*
* The migration process recreates the WorkSpace by using a new root volume from the target bundle image and the
* user volume from the last available snapshot of the original WorkSpace. During migration, the original
* D:\Users\%USERNAME% user profile folder is renamed to
* D:\Users\%USERNAME%MMddyyTHHmmss%.NotMigrated. A new D:\Users\%USERNAME%\ folder is
* generated by the new OS. Certain files in the old user profile are moved to the new user profile.
*
*
* For available migration scenarios, details about what happens during migration, and best practices, see Migrate a WorkSpace.
*
*
* @param migrateWorkspaceRequest
* @return Result of the MigrateWorkspace operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws OperationInProgressException
* The properties of this WorkSpace are currently being modified. Try again in a moment.
* @throws ResourceUnavailableException
* The specified resource is not available.
* @sample AmazonWorkspaces.MigrateWorkspace
* @see AWS
* API Documentation
*/
@Override
public MigrateWorkspaceResult migrateWorkspace(MigrateWorkspaceRequest request) {
request = beforeClientExecution(request);
return executeMigrateWorkspace(request);
}
@SdkInternalApi
final MigrateWorkspaceResult executeMigrateWorkspace(MigrateWorkspaceRequest migrateWorkspaceRequest) {
ExecutionContext executionContext = createExecutionContext(migrateWorkspaceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new MigrateWorkspaceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(migrateWorkspaceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "MigrateWorkspace");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new MigrateWorkspaceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the configuration of Bring Your Own License (BYOL) for the specified account.
*
*
* @param modifyAccountRequest
* @return Result of the ModifyAccount operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws ResourceUnavailableException
* The specified resource is not available.
* @throws ResourceNotFoundException
* The resource could not be found.
* @sample AmazonWorkspaces.ModifyAccount
* @see AWS API
* Documentation
*/
@Override
public ModifyAccountResult modifyAccount(ModifyAccountRequest request) {
request = beforeClientExecution(request);
return executeModifyAccount(request);
}
@SdkInternalApi
final ModifyAccountResult executeModifyAccount(ModifyAccountRequest modifyAccountRequest) {
ExecutionContext executionContext = createExecutionContext(modifyAccountRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyAccountRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(modifyAccountRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyAccount");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ModifyAccountResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the properties of the certificate-based authentication you want to use with your WorkSpaces.
*
*
* @param modifyCertificateBasedAuthPropertiesRequest
* @return Result of the ModifyCertificateBasedAuthProperties operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws ResourceNotFoundException
* The resource could not be found.
* @sample AmazonWorkspaces.ModifyCertificateBasedAuthProperties
* @see AWS API Documentation
*/
@Override
public ModifyCertificateBasedAuthPropertiesResult modifyCertificateBasedAuthProperties(ModifyCertificateBasedAuthPropertiesRequest request) {
request = beforeClientExecution(request);
return executeModifyCertificateBasedAuthProperties(request);
}
@SdkInternalApi
final ModifyCertificateBasedAuthPropertiesResult executeModifyCertificateBasedAuthProperties(
ModifyCertificateBasedAuthPropertiesRequest modifyCertificateBasedAuthPropertiesRequest) {
ExecutionContext executionContext = createExecutionContext(modifyCertificateBasedAuthPropertiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyCertificateBasedAuthPropertiesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(modifyCertificateBasedAuthPropertiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyCertificateBasedAuthProperties");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ModifyCertificateBasedAuthPropertiesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the properties of the specified Amazon WorkSpaces clients.
*
*
* @param modifyClientPropertiesRequest
* @return Result of the ModifyClientProperties operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.ModifyClientProperties
* @see AWS API Documentation
*/
@Override
public ModifyClientPropertiesResult modifyClientProperties(ModifyClientPropertiesRequest request) {
request = beforeClientExecution(request);
return executeModifyClientProperties(request);
}
@SdkInternalApi
final ModifyClientPropertiesResult executeModifyClientProperties(ModifyClientPropertiesRequest modifyClientPropertiesRequest) {
ExecutionContext executionContext = createExecutionContext(modifyClientPropertiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyClientPropertiesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(modifyClientPropertiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyClientProperties");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ModifyClientPropertiesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies multiple properties related to SAML 2.0 authentication, including the enablement status, user access
* URL, and relay state parameter name that are used for configuring federation with an SAML 2.0 identity provider.
*
*
* @param modifySamlPropertiesRequest
* @return Result of the ModifySamlProperties operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws OperationNotSupportedException
* This operation is not supported.
* @throws ResourceNotFoundException
* The resource could not be found.
* @sample AmazonWorkspaces.ModifySamlProperties
* @see AWS API Documentation
*/
@Override
public ModifySamlPropertiesResult modifySamlProperties(ModifySamlPropertiesRequest request) {
request = beforeClientExecution(request);
return executeModifySamlProperties(request);
}
@SdkInternalApi
final ModifySamlPropertiesResult executeModifySamlProperties(ModifySamlPropertiesRequest modifySamlPropertiesRequest) {
ExecutionContext executionContext = createExecutionContext(modifySamlPropertiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifySamlPropertiesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(modifySamlPropertiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifySamlProperties");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ModifySamlPropertiesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the self-service WorkSpace management capabilities for your users. For more information, see Enable Self-Service WorkSpace Management Capabilities for Your Users.
*
*
* @param modifySelfservicePermissionsRequest
* @return Result of the ModifySelfservicePermissions operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @sample AmazonWorkspaces.ModifySelfservicePermissions
* @see AWS API Documentation
*/
@Override
public ModifySelfservicePermissionsResult modifySelfservicePermissions(ModifySelfservicePermissionsRequest request) {
request = beforeClientExecution(request);
return executeModifySelfservicePermissions(request);
}
@SdkInternalApi
final ModifySelfservicePermissionsResult executeModifySelfservicePermissions(ModifySelfservicePermissionsRequest modifySelfservicePermissionsRequest) {
ExecutionContext executionContext = createExecutionContext(modifySelfservicePermissionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifySelfservicePermissionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(modifySelfservicePermissionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifySelfservicePermissions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ModifySelfservicePermissionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Specifies which devices and operating systems users can use to access their WorkSpaces. For more information, see
*
* Control Device Access.
*
*
* @param modifyWorkspaceAccessPropertiesRequest
* @return Result of the ModifyWorkspaceAccessProperties operation returned by the service.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.ModifyWorkspaceAccessProperties
* @see AWS API Documentation
*/
@Override
public ModifyWorkspaceAccessPropertiesResult modifyWorkspaceAccessProperties(ModifyWorkspaceAccessPropertiesRequest request) {
request = beforeClientExecution(request);
return executeModifyWorkspaceAccessProperties(request);
}
@SdkInternalApi
final ModifyWorkspaceAccessPropertiesResult executeModifyWorkspaceAccessProperties(
ModifyWorkspaceAccessPropertiesRequest modifyWorkspaceAccessPropertiesRequest) {
ExecutionContext executionContext = createExecutionContext(modifyWorkspaceAccessPropertiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyWorkspaceAccessPropertiesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(modifyWorkspaceAccessPropertiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyWorkspaceAccessProperties");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ModifyWorkspaceAccessPropertiesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modify the default properties used to create WorkSpaces.
*
*
* @param modifyWorkspaceCreationPropertiesRequest
* @return Result of the ModifyWorkspaceCreationProperties operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.ModifyWorkspaceCreationProperties
* @see AWS API Documentation
*/
@Override
public ModifyWorkspaceCreationPropertiesResult modifyWorkspaceCreationProperties(ModifyWorkspaceCreationPropertiesRequest request) {
request = beforeClientExecution(request);
return executeModifyWorkspaceCreationProperties(request);
}
@SdkInternalApi
final ModifyWorkspaceCreationPropertiesResult executeModifyWorkspaceCreationProperties(
ModifyWorkspaceCreationPropertiesRequest modifyWorkspaceCreationPropertiesRequest) {
ExecutionContext executionContext = createExecutionContext(modifyWorkspaceCreationPropertiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyWorkspaceCreationPropertiesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(modifyWorkspaceCreationPropertiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyWorkspaceCreationProperties");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ModifyWorkspaceCreationPropertiesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the specified WorkSpace properties. For important information about how to modify the size of the root
* and user volumes, see
* Modify a WorkSpace.
*
*
*
* The MANUAL running mode value is only supported by Amazon WorkSpaces Core. Contact your account team
* to be allow-listed to use this value. For more information, see Amazon WorkSpaces Core.
*
*
*
* @param modifyWorkspacePropertiesRequest
* @return Result of the ModifyWorkspaceProperties operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws OperationInProgressException
* The properties of this WorkSpace are currently being modified. Try again in a moment.
* @throws UnsupportedWorkspaceConfigurationException
* The configuration of this WorkSpace is not supported for this operation. For more information, see Required
* Configuration and Service Components for WorkSpaces .
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws ResourceUnavailableException
* The specified resource is not available.
* @sample AmazonWorkspaces.ModifyWorkspaceProperties
* @see AWS API Documentation
*/
@Override
public ModifyWorkspacePropertiesResult modifyWorkspaceProperties(ModifyWorkspacePropertiesRequest request) {
request = beforeClientExecution(request);
return executeModifyWorkspaceProperties(request);
}
@SdkInternalApi
final ModifyWorkspacePropertiesResult executeModifyWorkspaceProperties(ModifyWorkspacePropertiesRequest modifyWorkspacePropertiesRequest) {
ExecutionContext executionContext = createExecutionContext(modifyWorkspacePropertiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyWorkspacePropertiesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(modifyWorkspacePropertiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyWorkspaceProperties");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ModifyWorkspacePropertiesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets the state of the specified WorkSpace.
*
*
* To maintain a WorkSpace without being interrupted, set the WorkSpace state to ADMIN_MAINTENANCE.
* WorkSpaces in this state do not respond to requests to reboot, stop, start, rebuild, or restore. An AutoStop
* WorkSpace in this state is not stopped. Users cannot log into a WorkSpace in the ADMIN_MAINTENANCE
* state.
*
*
* @param modifyWorkspaceStateRequest
* @return Result of the ModifyWorkspaceState operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.ModifyWorkspaceState
* @see AWS API Documentation
*/
@Override
public ModifyWorkspaceStateResult modifyWorkspaceState(ModifyWorkspaceStateRequest request) {
request = beforeClientExecution(request);
return executeModifyWorkspaceState(request);
}
@SdkInternalApi
final ModifyWorkspaceStateResult executeModifyWorkspaceState(ModifyWorkspaceStateRequest modifyWorkspaceStateRequest) {
ExecutionContext executionContext = createExecutionContext(modifyWorkspaceStateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyWorkspaceStateRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(modifyWorkspaceStateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyWorkspaceState");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ModifyWorkspaceStateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Reboots the specified WorkSpaces.
*
*
* You cannot reboot a WorkSpace unless its state is AVAILABLE or UNHEALTHY.
*
*
* This operation is asynchronous and returns before the WorkSpaces have rebooted.
*
*
* @param rebootWorkspacesRequest
* @return Result of the RebootWorkspaces operation returned by the service.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.RebootWorkspaces
* @see AWS
* API Documentation
*/
@Override
public RebootWorkspacesResult rebootWorkspaces(RebootWorkspacesRequest request) {
request = beforeClientExecution(request);
return executeRebootWorkspaces(request);
}
@SdkInternalApi
final RebootWorkspacesResult executeRebootWorkspaces(RebootWorkspacesRequest rebootWorkspacesRequest) {
ExecutionContext executionContext = createExecutionContext(rebootWorkspacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RebootWorkspacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(rebootWorkspacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RebootWorkspaces");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RebootWorkspacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Rebuilds the specified WorkSpace.
*
*
* You cannot rebuild a WorkSpace unless its state is AVAILABLE, ERROR,
* UNHEALTHY, STOPPED, or REBOOTING.
*
*
* Rebuilding a WorkSpace is a potentially destructive action that can result in the loss of data. For more
* information, see Rebuild
* a WorkSpace.
*
*
* This operation is asynchronous and returns before the WorkSpaces have been completely rebuilt.
*
*
* @param rebuildWorkspacesRequest
* @return Result of the RebuildWorkspaces operation returned by the service.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.RebuildWorkspaces
* @see AWS
* API Documentation
*/
@Override
public RebuildWorkspacesResult rebuildWorkspaces(RebuildWorkspacesRequest request) {
request = beforeClientExecution(request);
return executeRebuildWorkspaces(request);
}
@SdkInternalApi
final RebuildWorkspacesResult executeRebuildWorkspaces(RebuildWorkspacesRequest rebuildWorkspacesRequest) {
ExecutionContext executionContext = createExecutionContext(rebuildWorkspacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RebuildWorkspacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(rebuildWorkspacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RebuildWorkspaces");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RebuildWorkspacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Registers the specified directory. This operation is asynchronous and returns before the WorkSpace directory is
* registered. If this is the first time you are registering a directory, you will need to create the
* workspaces_DefaultRole role before you can register a directory. For more information, see
* Creating the workspaces_DefaultRole Role.
*
*
* @param registerWorkspaceDirectoryRequest
* @return Result of the RegisterWorkspaceDirectory operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws WorkspacesDefaultRoleNotFoundException
* The workspaces_DefaultRole role could not be found. If this is the first time you are registering a
* directory, you will need to create the workspaces_DefaultRole role before you can register a directory.
* For more information, see Creating the workspaces_DefaultRole Role.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws UnsupportedNetworkConfigurationException
* The configuration of this network is not supported for this operation, or your network configuration
* conflicts with the Amazon WorkSpaces management network IP range. For more information, see Configure a
* VPC for Amazon WorkSpaces.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.RegisterWorkspaceDirectory
* @see AWS API Documentation
*/
@Override
public RegisterWorkspaceDirectoryResult registerWorkspaceDirectory(RegisterWorkspaceDirectoryRequest request) {
request = beforeClientExecution(request);
return executeRegisterWorkspaceDirectory(request);
}
@SdkInternalApi
final RegisterWorkspaceDirectoryResult executeRegisterWorkspaceDirectory(RegisterWorkspaceDirectoryRequest registerWorkspaceDirectoryRequest) {
ExecutionContext executionContext = createExecutionContext(registerWorkspaceDirectoryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RegisterWorkspaceDirectoryRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(registerWorkspaceDirectoryRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RegisterWorkspaceDirectory");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RegisterWorkspaceDirectoryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Restores the specified WorkSpace to its last known healthy state.
*
*
* You cannot restore a WorkSpace unless its state is AVAILABLE, ERROR,
* UNHEALTHY, or STOPPED.
*
*
* Restoring a WorkSpace is a potentially destructive action that can result in the loss of data. For more
* information, see Restore a WorkSpace.
*
*
* This operation is asynchronous and returns before the WorkSpace is completely restored.
*
*
* @param restoreWorkspaceRequest
* @return Result of the RestoreWorkspace operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.RestoreWorkspace
* @see AWS
* API Documentation
*/
@Override
public RestoreWorkspaceResult restoreWorkspace(RestoreWorkspaceRequest request) {
request = beforeClientExecution(request);
return executeRestoreWorkspace(request);
}
@SdkInternalApi
final RestoreWorkspaceResult executeRestoreWorkspace(RestoreWorkspaceRequest restoreWorkspaceRequest) {
ExecutionContext executionContext = createExecutionContext(restoreWorkspaceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RestoreWorkspaceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(restoreWorkspaceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RestoreWorkspace");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RestoreWorkspaceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Removes one or more rules from the specified IP access control group.
*
*
* @param revokeIpRulesRequest
* @return Result of the RevokeIpRules operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.RevokeIpRules
* @see AWS API
* Documentation
*/
@Override
public RevokeIpRulesResult revokeIpRules(RevokeIpRulesRequest request) {
request = beforeClientExecution(request);
return executeRevokeIpRules(request);
}
@SdkInternalApi
final RevokeIpRulesResult executeRevokeIpRules(RevokeIpRulesRequest revokeIpRulesRequest) {
ExecutionContext executionContext = createExecutionContext(revokeIpRulesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RevokeIpRulesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(revokeIpRulesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RevokeIpRules");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RevokeIpRulesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Starts the specified WorkSpaces.
*
*
* You cannot start a WorkSpace unless it has a running mode of AutoStop and a state of
* STOPPED.
*
*
* @param startWorkspacesRequest
* @return Result of the StartWorkspaces operation returned by the service.
* @sample AmazonWorkspaces.StartWorkspaces
* @see AWS API
* Documentation
*/
@Override
public StartWorkspacesResult startWorkspaces(StartWorkspacesRequest request) {
request = beforeClientExecution(request);
return executeStartWorkspaces(request);
}
@SdkInternalApi
final StartWorkspacesResult executeStartWorkspaces(StartWorkspacesRequest startWorkspacesRequest) {
ExecutionContext executionContext = createExecutionContext(startWorkspacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartWorkspacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(startWorkspacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartWorkspaces");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new StartWorkspacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Stops the specified WorkSpaces.
*
*
* You cannot stop a WorkSpace unless it has a running mode of AutoStop and a state of
* AVAILABLE, IMPAIRED, UNHEALTHY, or ERROR.
*
*
* @param stopWorkspacesRequest
* @return Result of the StopWorkspaces operation returned by the service.
* @sample AmazonWorkspaces.StopWorkspaces
* @see AWS API
* Documentation
*/
@Override
public StopWorkspacesResult stopWorkspaces(StopWorkspacesRequest request) {
request = beforeClientExecution(request);
return executeStopWorkspaces(request);
}
@SdkInternalApi
final StopWorkspacesResult executeStopWorkspaces(StopWorkspacesRequest stopWorkspacesRequest) {
ExecutionContext executionContext = createExecutionContext(stopWorkspacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StopWorkspacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(stopWorkspacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StopWorkspaces");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new StopWorkspacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Terminates the specified WorkSpaces.
*
*
*
* Terminating a WorkSpace is a permanent action and cannot be undone. The user's data is destroyed. If you need to
* archive any user data, contact Amazon Web Services Support before terminating the WorkSpace.
*
*
*
* You can terminate a WorkSpace that is in any state except SUSPENDED.
*
*
* This operation is asynchronous and returns before the WorkSpaces have been completely terminated. After a
* WorkSpace is terminated, the TERMINATED state is returned only briefly before the WorkSpace
* directory metadata is cleaned up, so this state is rarely returned. To confirm that a WorkSpace is terminated,
* check for the WorkSpace ID by using DescribeWorkSpaces. If
* the WorkSpace ID isn't returned, then the WorkSpace has been successfully terminated.
*
*
*
* Simple AD and AD Connector are made available to you free of charge to use with WorkSpaces. If there are no
* WorkSpaces being used with your Simple AD or AD Connector directory for 30 consecutive days, this directory will
* be automatically deregistered for use with Amazon WorkSpaces, and you will be charged for this directory as per
* the Directory Service pricing terms.
*
*
* To delete empty directories, see Delete the
* Directory for Your WorkSpaces. If you delete your Simple AD or AD Connector directory, you can always create
* a new one when you want to start using WorkSpaces again.
*
*
*
* @param terminateWorkspacesRequest
* @return Result of the TerminateWorkspaces operation returned by the service.
* @sample AmazonWorkspaces.TerminateWorkspaces
* @see AWS
* API Documentation
*/
@Override
public TerminateWorkspacesResult terminateWorkspaces(TerminateWorkspacesRequest request) {
request = beforeClientExecution(request);
return executeTerminateWorkspaces(request);
}
@SdkInternalApi
final TerminateWorkspacesResult executeTerminateWorkspaces(TerminateWorkspacesRequest terminateWorkspacesRequest) {
ExecutionContext executionContext = createExecutionContext(terminateWorkspacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TerminateWorkspacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(terminateWorkspacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TerminateWorkspaces");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TerminateWorkspacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a Amazon Connect client add-in. Use this action to update the name and endpoint URL of a Amazon Connect
* client add-in.
*
*
* @param updateConnectClientAddInRequest
* @return Result of the UpdateConnectClientAddIn operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.UpdateConnectClientAddIn
* @see AWS API Documentation
*/
@Override
public UpdateConnectClientAddInResult updateConnectClientAddIn(UpdateConnectClientAddInRequest request) {
request = beforeClientExecution(request);
return executeUpdateConnectClientAddIn(request);
}
@SdkInternalApi
final UpdateConnectClientAddInResult executeUpdateConnectClientAddIn(UpdateConnectClientAddInRequest updateConnectClientAddInRequest) {
ExecutionContext executionContext = createExecutionContext(updateConnectClientAddInRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateConnectClientAddInRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateConnectClientAddInRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateConnectClientAddIn");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateConnectClientAddInResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Shares or unshares a connection alias with one account by specifying whether that account has permission to
* associate the connection alias with a directory. If the association permission is granted, the connection alias
* is shared with that account. If the association permission is revoked, the connection alias is unshared with the
* account. For more information, see Cross-Region
* Redirection for Amazon WorkSpaces.
*
*
*
* -
*
* Before performing this operation, call
* DescribeConnectionAliases to make sure that the current state of the connection alias is CREATED
* .
*
*
* -
*
* To delete a connection alias that has been shared, the shared account must first disassociate the connection
* alias from any directories it has been associated with. Then you must unshare the connection alias from the
* account it has been shared with. You can delete a connection alias only after it is no longer shared with any
* accounts or associated with any directories.
*
*
*
*
*
* @param updateConnectionAliasPermissionRequest
* @return Result of the UpdateConnectionAliasPermission operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceAssociatedException
* The resource is associated with a directory.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.UpdateConnectionAliasPermission
* @see AWS API Documentation
*/
@Override
public UpdateConnectionAliasPermissionResult updateConnectionAliasPermission(UpdateConnectionAliasPermissionRequest request) {
request = beforeClientExecution(request);
return executeUpdateConnectionAliasPermission(request);
}
@SdkInternalApi
final UpdateConnectionAliasPermissionResult executeUpdateConnectionAliasPermission(
UpdateConnectionAliasPermissionRequest updateConnectionAliasPermissionRequest) {
ExecutionContext executionContext = createExecutionContext(updateConnectionAliasPermissionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateConnectionAliasPermissionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateConnectionAliasPermissionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateConnectionAliasPermission");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateConnectionAliasPermissionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Replaces the current rules of the specified IP access control group with the specified rules.
*
*
* @param updateRulesOfIpGroupRequest
* @return Result of the UpdateRulesOfIpGroup operation returned by the service.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceLimitExceededException
* Your resource limits have been exceeded.
* @throws InvalidResourceStateException
* The state of the resource is not valid for this operation.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @sample AmazonWorkspaces.UpdateRulesOfIpGroup
* @see AWS API Documentation
*/
@Override
public UpdateRulesOfIpGroupResult updateRulesOfIpGroup(UpdateRulesOfIpGroupRequest request) {
request = beforeClientExecution(request);
return executeUpdateRulesOfIpGroup(request);
}
@SdkInternalApi
final UpdateRulesOfIpGroupResult executeUpdateRulesOfIpGroup(UpdateRulesOfIpGroupRequest updateRulesOfIpGroupRequest) {
ExecutionContext executionContext = createExecutionContext(updateRulesOfIpGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateRulesOfIpGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateRulesOfIpGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateRulesOfIpGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateRulesOfIpGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a WorkSpace bundle with a new image. For more information about updating WorkSpace bundles, see Update a Custom
* WorkSpaces Bundle.
*
*
*
* Existing WorkSpaces aren't automatically updated when you update the bundle that they're based on. To update
* existing WorkSpaces that are based on a bundle that you've updated, you must either rebuild the WorkSpaces or
* delete and recreate them.
*
*
*
* @param updateWorkspaceBundleRequest
* @return Result of the UpdateWorkspaceBundle operation returned by the service.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceUnavailableException
* The specified resource is not available.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.UpdateWorkspaceBundle
* @see AWS API Documentation
*/
@Override
public UpdateWorkspaceBundleResult updateWorkspaceBundle(UpdateWorkspaceBundleRequest request) {
request = beforeClientExecution(request);
return executeUpdateWorkspaceBundle(request);
}
@SdkInternalApi
final UpdateWorkspaceBundleResult executeUpdateWorkspaceBundle(UpdateWorkspaceBundleRequest updateWorkspaceBundleRequest) {
ExecutionContext executionContext = createExecutionContext(updateWorkspaceBundleRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateWorkspaceBundleRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateWorkspaceBundleRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateWorkspaceBundle");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateWorkspaceBundleResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Shares or unshares an image with one account in the same Amazon Web Services Region by specifying whether that
* account has permission to copy the image. If the copy image permission is granted, the image is shared with that
* account. If the copy image permission is revoked, the image is unshared with the account.
*
*
* After an image has been shared, the recipient account can copy the image to other Regions as needed.
*
*
* In the China (Ningxia) Region, you can copy images only within the same Region.
*
*
* In Amazon Web Services GovCloud (US), to copy images to and from other Regions, contact Amazon Web Services
* Support.
*
*
* For more information about sharing images, see Share or Unshare a
* Custom WorkSpaces Image.
*
*
*
* -
*
* To delete an image that has been shared, you must unshare the image before you delete it.
*
*
* -
*
* Sharing Bring Your Own License (BYOL) images across Amazon Web Services accounts isn't supported at this time in
* Amazon Web Services GovCloud (US). To share BYOL images across accounts in Amazon Web Services GovCloud (US),
* contact Amazon Web Services Support.
*
*
*
*
*
* @param updateWorkspaceImagePermissionRequest
* @return Result of the UpdateWorkspaceImagePermission operation returned by the service.
* @throws ResourceNotFoundException
* The resource could not be found.
* @throws ResourceUnavailableException
* The specified resource is not available.
* @throws AccessDeniedException
* The user is not authorized to access a resource.
* @throws InvalidParameterValuesException
* One or more parameter values are not valid.
* @throws OperationNotSupportedException
* This operation is not supported.
* @sample AmazonWorkspaces.UpdateWorkspaceImagePermission
* @see AWS API Documentation
*/
@Override
public UpdateWorkspaceImagePermissionResult updateWorkspaceImagePermission(UpdateWorkspaceImagePermissionRequest request) {
request = beforeClientExecution(request);
return executeUpdateWorkspaceImagePermission(request);
}
@SdkInternalApi
final UpdateWorkspaceImagePermissionResult executeUpdateWorkspaceImagePermission(UpdateWorkspaceImagePermissionRequest updateWorkspaceImagePermissionRequest) {
ExecutionContext executionContext = createExecutionContext(updateWorkspaceImagePermissionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateWorkspaceImagePermissionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateWorkspaceImagePermissionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "WorkSpaces");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateWorkspaceImagePermission");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateWorkspaceImagePermissionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
@Override
public void shutdown() {
super.shutdown();
}
}