/*
* Copyright 2018-2023 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.proton;
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.proton.AWSProtonClientBuilder;
import com.amazonaws.services.proton.waiters.AWSProtonWaiters;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.proton.model.*;
import com.amazonaws.services.proton.model.transform.*;
/**
* Client for accessing AWS Proton. All service calls made using this client are blocking, and will not return until the
* service call completes.
*
*
* This is the Proton Service API Reference. It provides descriptions, syntax and usage examples for each of the actions and data types for the Proton service.
*
*
* The documentation for each action shows the Query API request parameters and the XML response.
*
*
* Alternatively, you can use the Amazon Web Services CLI to access an API. For more information, see the Amazon Web Services Command Line
* Interface User Guide.
*
*
* The Proton service is a two-pronged automation framework. Administrators create service templates to provide
* standardized infrastructure and deployment tooling for serverless and container based applications. Developers, in
* turn, select from the available service templates to automate their application or service deployments.
*
*
* Because administrators define the infrastructure and tooling that Proton deploys and manages, they need permissions
* to use all of the listed API operations.
*
*
* When developers select a specific infrastructure and tooling set, Proton deploys their applications. To monitor their
* applications that are running on Proton, developers need permissions to the service create, list,
* update and delete API operations and the service instance list and update API operations.
*
*
* To learn more about Proton, see the Proton
* User Guide.
*
*
* Ensuring Idempotency
*
*
* When you make a mutating API request, the request typically returns a result before the asynchronous workflows of the
* operation are complete. Operations might also time out or encounter other server issues before they're complete, even
* if the request already returned a result. This might make it difficult to determine whether the request succeeded.
* Moreover, you might need to retry the request multiple times to ensure that the operation completes successfully.
* However, if the original request and the subsequent retries are successful, the operation occurs multiple times. This
* means that you might create more resources than you intended.
*
*
* Idempotency ensures that an API request action completes no more than one time. With an idempotent request, if
* the original request action completes successfully, any subsequent retries complete successfully without performing
* any further actions. However, the result might contain updated information, such as the current creation status.
*
*
* The following lists of APIs are grouped according to methods that ensure idempotency.
*
*
* Idempotent create APIs with a client token
*
*
* The API actions in this list support idempotency with the use of a client token. The corresponding Amazon Web
* Services CLI commands also support idempotency using a client token. A client token is a unique, case-sensitive
* string of up to 64 ASCII characters. To make an idempotent API request using one of these actions, specify a client
* token in the request. We recommend that you don't reuse the same client token for other API requests. If you
* don’t provide a client token for these APIs, a default client token is automatically provided by SDKs.
*
*
* Given a request action that has succeeded:
*
*
* If you retry the request using the same client token and the same parameters, the retry succeeds without performing
* any further actions other than returning the original resource detail data in the response.
*
*
* If you retry the request using the same client token, but one or more of the parameters are different, the retry
* throws a ValidationException with an IdempotentParameterMismatch error.
*
*
* Client tokens expire eight hours after a request is made. If you retry the request with the expired token, a new
* resource is created.
*
*
* If the original resource is deleted and you retry the request, a new resource is created.
*
*
* Idempotent create APIs with a client token:
*
*
* -
*
* CreateEnvironmentTemplateVersion
*
*
* -
*
* CreateServiceTemplateVersion
*
*
* -
*
* CreateEnvironmentAccountConnection
*
*
*
*
* Idempotent create APIs
*
*
* Given a request action that has succeeded:
*
*
* If you retry the request with an API from this group, and the original resource hasn't been modified, the
* retry succeeds without performing any further actions other than returning the original resource detail data in the
* response.
*
*
* If the original resource has been modified, the retry throws a ConflictException.
*
*
* If you retry with different input parameters, the retry throws a ValidationException with an
* IdempotentParameterMismatch error.
*
*
* Idempotent create APIs:
*
*
*
* Idempotent delete APIs
*
*
* Given a request action that has succeeded:
*
*
* When you retry the request with an API from this group and the resource was deleted, its metadata is returned in the
* response.
*
*
* If you retry and the resource doesn't exist, the response is empty.
*
*
* In both cases, the retry succeeds.
*
*
* Idempotent delete APIs:
*
*
* -
*
* DeleteEnvironmentTemplate
*
*
* -
*
* DeleteEnvironmentTemplateVersion
*
*
* -
*
* DeleteServiceTemplate
*
*
* -
*
* DeleteServiceTemplateVersion
*
*
* -
*
* DeleteEnvironmentAccountConnection
*
*
*
*
* Asynchronous idempotent delete APIs
*
*
* Given a request action that has succeeded:
*
*
* If you retry the request with an API from this group, if the original request delete operation status is
* DELETE_IN_PROGRESS, the retry returns the resource detail data in the response without performing any
* further actions.
*
*
* If the original request delete operation is complete, a retry returns an empty response.
*
*
* Asynchronous idempotent delete APIs:
*
*
* -
*
* DeleteEnvironment
*
*
* -
*
* DeleteService
*
*
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSProtonClient extends AmazonWebServiceClient implements AWSProton {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AWSProton.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "proton";
private volatile AWSProtonWaiters waiters;
/** 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.0")
.withSupportsCbor(false)
.withSupportsIon(false)
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServiceQuotaExceededException").withExceptionUnmarshaller(
com.amazonaws.services.proton.model.transform.ServiceQuotaExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InternalServerException").withExceptionUnmarshaller(
com.amazonaws.services.proton.model.transform.InternalServerExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.proton.model.transform.ResourceNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ValidationException").withExceptionUnmarshaller(
com.amazonaws.services.proton.model.transform.ValidationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ThrottlingException").withExceptionUnmarshaller(
com.amazonaws.services.proton.model.transform.ThrottlingExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AccessDeniedException").withExceptionUnmarshaller(
com.amazonaws.services.proton.model.transform.AccessDeniedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ConflictException").withExceptionUnmarshaller(
com.amazonaws.services.proton.model.transform.ConflictExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.proton.model.AWSProtonException.class));
public static AWSProtonClientBuilder builder() {
return AWSProtonClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on AWS Proton 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.
*/
AWSProtonClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on AWS Proton 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.
*/
AWSProtonClient(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("proton.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/proton/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/proton/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* In a management account, an environment account connection request is accepted. When the environment account
* connection request is accepted, Proton can use the associated IAM role to provision environment infrastructure
* resources in the associated environment account.
*
*
* For more information, see Environment account
* connections in the Proton User guide.
*
*
* @param acceptEnvironmentAccountConnectionRequest
* @return Result of the AcceptEnvironmentAccountConnection operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.AcceptEnvironmentAccountConnection
* @see AWS API Documentation
*/
@Override
public AcceptEnvironmentAccountConnectionResult acceptEnvironmentAccountConnection(AcceptEnvironmentAccountConnectionRequest request) {
request = beforeClientExecution(request);
return executeAcceptEnvironmentAccountConnection(request);
}
@SdkInternalApi
final AcceptEnvironmentAccountConnectionResult executeAcceptEnvironmentAccountConnection(
AcceptEnvironmentAccountConnectionRequest acceptEnvironmentAccountConnectionRequest) {
ExecutionContext executionContext = createExecutionContext(acceptEnvironmentAccountConnectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AcceptEnvironmentAccountConnectionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(acceptEnvironmentAccountConnectionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AcceptEnvironmentAccountConnection");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new AcceptEnvironmentAccountConnectionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Attempts to cancel a component deployment (for a component that is in the IN_PROGRESS deployment
* status).
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
* @param cancelComponentDeploymentRequest
* @return Result of the CancelComponentDeployment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CancelComponentDeployment
* @see AWS API Documentation
*/
@Override
public CancelComponentDeploymentResult cancelComponentDeployment(CancelComponentDeploymentRequest request) {
request = beforeClientExecution(request);
return executeCancelComponentDeployment(request);
}
@SdkInternalApi
final CancelComponentDeploymentResult executeCancelComponentDeployment(CancelComponentDeploymentRequest cancelComponentDeploymentRequest) {
ExecutionContext executionContext = createExecutionContext(cancelComponentDeploymentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelComponentDeploymentRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(cancelComponentDeploymentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelComponentDeployment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CancelComponentDeploymentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Attempts to cancel an environment deployment on an UpdateEnvironment action, if the deployment is
* IN_PROGRESS. For more information, see Update an environment in the
* Proton User guide.
*
*
* The following list includes potential cancellation scenarios.
*
*
* -
*
* If the cancellation attempt succeeds, the resulting deployment state is CANCELLED.
*
*
* -
*
* If the cancellation attempt fails, the resulting deployment state is FAILED.
*
*
* -
*
* If the current UpdateEnvironment action succeeds before the cancellation attempt starts, the resulting
* deployment state is SUCCEEDED and the cancellation attempt has no effect.
*
*
*
*
* @param cancelEnvironmentDeploymentRequest
* @return Result of the CancelEnvironmentDeployment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CancelEnvironmentDeployment
* @see AWS API Documentation
*/
@Override
public CancelEnvironmentDeploymentResult cancelEnvironmentDeployment(CancelEnvironmentDeploymentRequest request) {
request = beforeClientExecution(request);
return executeCancelEnvironmentDeployment(request);
}
@SdkInternalApi
final CancelEnvironmentDeploymentResult executeCancelEnvironmentDeployment(CancelEnvironmentDeploymentRequest cancelEnvironmentDeploymentRequest) {
ExecutionContext executionContext = createExecutionContext(cancelEnvironmentDeploymentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelEnvironmentDeploymentRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(cancelEnvironmentDeploymentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelEnvironmentDeployment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CancelEnvironmentDeploymentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Attempts to cancel a service instance deployment on an UpdateServiceInstance action, if the deployment is
* IN_PROGRESS. For more information, see Update a service
* instance in the Proton User guide.
*
*
* The following list includes potential cancellation scenarios.
*
*
* -
*
* If the cancellation attempt succeeds, the resulting deployment state is CANCELLED.
*
*
* -
*
* If the cancellation attempt fails, the resulting deployment state is FAILED.
*
*
* -
*
* If the current UpdateServiceInstance action succeeds before the cancellation attempt starts, the resulting
* deployment state is SUCCEEDED and the cancellation attempt has no effect.
*
*
*
*
* @param cancelServiceInstanceDeploymentRequest
* @return Result of the CancelServiceInstanceDeployment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CancelServiceInstanceDeployment
* @see AWS API Documentation
*/
@Override
public CancelServiceInstanceDeploymentResult cancelServiceInstanceDeployment(CancelServiceInstanceDeploymentRequest request) {
request = beforeClientExecution(request);
return executeCancelServiceInstanceDeployment(request);
}
@SdkInternalApi
final CancelServiceInstanceDeploymentResult executeCancelServiceInstanceDeployment(
CancelServiceInstanceDeploymentRequest cancelServiceInstanceDeploymentRequest) {
ExecutionContext executionContext = createExecutionContext(cancelServiceInstanceDeploymentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelServiceInstanceDeploymentRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(cancelServiceInstanceDeploymentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelServiceInstanceDeployment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CancelServiceInstanceDeploymentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Attempts to cancel a service pipeline deployment on an UpdateServicePipeline action, if the deployment is
* IN_PROGRESS. For more information, see Update a service
* pipeline in the Proton User guide.
*
*
* The following list includes potential cancellation scenarios.
*
*
* -
*
* If the cancellation attempt succeeds, the resulting deployment state is CANCELLED.
*
*
* -
*
* If the cancellation attempt fails, the resulting deployment state is FAILED.
*
*
* -
*
* If the current UpdateServicePipeline action succeeds before the cancellation attempt starts, the resulting
* deployment state is SUCCEEDED and the cancellation attempt has no effect.
*
*
*
*
* @param cancelServicePipelineDeploymentRequest
* @return Result of the CancelServicePipelineDeployment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CancelServicePipelineDeployment
* @see AWS API Documentation
*/
@Override
public CancelServicePipelineDeploymentResult cancelServicePipelineDeployment(CancelServicePipelineDeploymentRequest request) {
request = beforeClientExecution(request);
return executeCancelServicePipelineDeployment(request);
}
@SdkInternalApi
final CancelServicePipelineDeploymentResult executeCancelServicePipelineDeployment(
CancelServicePipelineDeploymentRequest cancelServicePipelineDeploymentRequest) {
ExecutionContext executionContext = createExecutionContext(cancelServicePipelineDeploymentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelServicePipelineDeploymentRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(cancelServicePipelineDeploymentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelServicePipelineDeployment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CancelServicePipelineDeploymentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create an Proton component. A component is an infrastructure extension for a service instance.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
* @param createComponentRequest
* @return Result of the CreateComponent operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateComponent
* @see AWS API
* Documentation
*/
@Override
public CreateComponentResult createComponent(CreateComponentRequest request) {
request = beforeClientExecution(request);
return executeCreateComponent(request);
}
@SdkInternalApi
final CreateComponentResult executeCreateComponent(CreateComponentRequest createComponentRequest) {
ExecutionContext executionContext = createExecutionContext(createComponentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateComponentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createComponentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateComponent");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateComponentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deploy a new environment. An Proton environment is created from an environment template that defines
* infrastructure and resources that can be shared across services.
*
*
* You can provision environments using the following methods:
*
*
* -
*
* Amazon Web Services-managed provisioning: Proton makes direct calls to provision your resources.
*
*
* -
*
* Self-managed provisioning: Proton makes pull requests on your repository to provide compiled infrastructure as
* code (IaC) files that your IaC engine uses to provision resources.
*
*
*
*
* For more information, see Environments and Provisioning methods in
* the Proton User Guide.
*
*
* @param createEnvironmentRequest
* @return Result of the CreateEnvironment operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateEnvironment
* @see AWS API
* Documentation
*/
@Override
public CreateEnvironmentResult createEnvironment(CreateEnvironmentRequest request) {
request = beforeClientExecution(request);
return executeCreateEnvironment(request);
}
@SdkInternalApi
final CreateEnvironmentResult executeCreateEnvironment(CreateEnvironmentRequest createEnvironmentRequest) {
ExecutionContext executionContext = createExecutionContext(createEnvironmentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateEnvironmentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createEnvironmentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateEnvironment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateEnvironmentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create an environment account connection in an environment account so that environment infrastructure resources
* can be provisioned in the environment account from a management account.
*
*
* An environment account connection is a secure bi-directional connection between a management account and
* an environment account that maintains authorization and permissions. For more information, see Environment account
* connections in the Proton User guide.
*
*
* @param createEnvironmentAccountConnectionRequest
* @return Result of the CreateEnvironmentAccountConnection operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateEnvironmentAccountConnection
* @see AWS API Documentation
*/
@Override
public CreateEnvironmentAccountConnectionResult createEnvironmentAccountConnection(CreateEnvironmentAccountConnectionRequest request) {
request = beforeClientExecution(request);
return executeCreateEnvironmentAccountConnection(request);
}
@SdkInternalApi
final CreateEnvironmentAccountConnectionResult executeCreateEnvironmentAccountConnection(
CreateEnvironmentAccountConnectionRequest createEnvironmentAccountConnectionRequest) {
ExecutionContext executionContext = createExecutionContext(createEnvironmentAccountConnectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateEnvironmentAccountConnectionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createEnvironmentAccountConnectionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateEnvironmentAccountConnection");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateEnvironmentAccountConnectionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create an environment template for Proton. For more information, see Environment Templates in the
* Proton User Guide.
*
*
* You can create an environment template in one of the two following ways:
*
*
* -
*
* Register and publish a standard environment template that instructs Proton to deploy and manage
* environment infrastructure.
*
*
* -
*
* Register and publish a customer managed environment template that connects Proton to your existing
* provisioned infrastructure that you manage. Proton doesn't manage your existing provisioned
* infrastructure. To create an environment template for customer provisioned and managed infrastructure, include
* the provisioning parameter and set the value to CUSTOMER_MANAGED. For more information,
* see Register and publish an
* environment template in the Proton User Guide.
*
*
*
*
* @param createEnvironmentTemplateRequest
* @return Result of the CreateEnvironmentTemplate operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateEnvironmentTemplate
* @see AWS API Documentation
*/
@Override
public CreateEnvironmentTemplateResult createEnvironmentTemplate(CreateEnvironmentTemplateRequest request) {
request = beforeClientExecution(request);
return executeCreateEnvironmentTemplate(request);
}
@SdkInternalApi
final CreateEnvironmentTemplateResult executeCreateEnvironmentTemplate(CreateEnvironmentTemplateRequest createEnvironmentTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(createEnvironmentTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateEnvironmentTemplateRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createEnvironmentTemplateRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateEnvironmentTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateEnvironmentTemplateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create a new major or minor version of an environment template. A major version of an environment template is a
* version that isn't backwards compatible. A minor version of an environment template is a version that's
* backwards compatible within its major version.
*
*
* @param createEnvironmentTemplateVersionRequest
* @return Result of the CreateEnvironmentTemplateVersion operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateEnvironmentTemplateVersion
* @see AWS API Documentation
*/
@Override
public CreateEnvironmentTemplateVersionResult createEnvironmentTemplateVersion(CreateEnvironmentTemplateVersionRequest request) {
request = beforeClientExecution(request);
return executeCreateEnvironmentTemplateVersion(request);
}
@SdkInternalApi
final CreateEnvironmentTemplateVersionResult executeCreateEnvironmentTemplateVersion(
CreateEnvironmentTemplateVersionRequest createEnvironmentTemplateVersionRequest) {
ExecutionContext executionContext = createExecutionContext(createEnvironmentTemplateVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateEnvironmentTemplateVersionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createEnvironmentTemplateVersionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateEnvironmentTemplateVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateEnvironmentTemplateVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create and register a link to a repository. Proton uses the link to repeatedly access the repository, to either
* push to it (self-managed provisioning) or pull from it (template sync). You can share a linked repository across
* multiple resources (like environments using self-managed provisioning, or synced templates). When you create a
* repository link, Proton creates a service-linked
* role for you.
*
*
* For more information, see Self-managed provisioning, Template bundles, and Template sync
* configurations in the Proton User Guide.
*
*
* @param createRepositoryRequest
* @return Result of the CreateRepository operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateRepository
* @see AWS API
* Documentation
*/
@Override
public CreateRepositoryResult createRepository(CreateRepositoryRequest request) {
request = beforeClientExecution(request);
return executeCreateRepository(request);
}
@SdkInternalApi
final CreateRepositoryResult executeCreateRepository(CreateRepositoryRequest createRepositoryRequest) {
ExecutionContext executionContext = createExecutionContext(createRepositoryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateRepositoryRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createRepositoryRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateRepository");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateRepositoryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create an Proton service. An Proton service is an instantiation of a service template and often includes several
* service instances and pipeline. For more information, see Services in the Proton User
* Guide.
*
*
* @param createServiceRequest
* @return Result of the CreateService operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateService
* @see AWS API
* Documentation
*/
@Override
public CreateServiceResult createService(CreateServiceRequest request) {
request = beforeClientExecution(request);
return executeCreateService(request);
}
@SdkInternalApi
final CreateServiceResult executeCreateService(CreateServiceRequest createServiceRequest) {
ExecutionContext executionContext = createExecutionContext(createServiceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateServiceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createServiceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateService");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateServiceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create a service instance.
*
*
* @param createServiceInstanceRequest
* @return Result of the CreateServiceInstance operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateServiceInstance
* @see AWS
* API Documentation
*/
@Override
public CreateServiceInstanceResult createServiceInstance(CreateServiceInstanceRequest request) {
request = beforeClientExecution(request);
return executeCreateServiceInstance(request);
}
@SdkInternalApi
final CreateServiceInstanceResult executeCreateServiceInstance(CreateServiceInstanceRequest createServiceInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(createServiceInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateServiceInstanceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createServiceInstanceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateServiceInstance");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateServiceInstanceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create the Proton Ops configuration file.
*
*
* @param createServiceSyncConfigRequest
* @return Result of the CreateServiceSyncConfig operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateServiceSyncConfig
* @see AWS
* API Documentation
*/
@Override
public CreateServiceSyncConfigResult createServiceSyncConfig(CreateServiceSyncConfigRequest request) {
request = beforeClientExecution(request);
return executeCreateServiceSyncConfig(request);
}
@SdkInternalApi
final CreateServiceSyncConfigResult executeCreateServiceSyncConfig(CreateServiceSyncConfigRequest createServiceSyncConfigRequest) {
ExecutionContext executionContext = createExecutionContext(createServiceSyncConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateServiceSyncConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createServiceSyncConfigRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateServiceSyncConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateServiceSyncConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create a service template. The administrator creates a service template to define standardized infrastructure and
* an optional CI/CD service pipeline. Developers, in turn, select the service template from Proton. If the selected
* service template includes a service pipeline definition, they provide a link to their source code repository.
* Proton then deploys and manages the infrastructure defined by the selected service template. For more
* information, see Proton
* templates in the Proton User Guide.
*
*
* @param createServiceTemplateRequest
* @return Result of the CreateServiceTemplate operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateServiceTemplate
* @see AWS
* API Documentation
*/
@Override
public CreateServiceTemplateResult createServiceTemplate(CreateServiceTemplateRequest request) {
request = beforeClientExecution(request);
return executeCreateServiceTemplate(request);
}
@SdkInternalApi
final CreateServiceTemplateResult executeCreateServiceTemplate(CreateServiceTemplateRequest createServiceTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(createServiceTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateServiceTemplateRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createServiceTemplateRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateServiceTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateServiceTemplateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Create a new major or minor version of a service template. A major version of a service template is a version
* that isn't backward compatible. A minor version of a service template is a version that's backward
* compatible within its major version.
*
*
* @param createServiceTemplateVersionRequest
* @return Result of the CreateServiceTemplateVersion operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateServiceTemplateVersion
* @see AWS API Documentation
*/
@Override
public CreateServiceTemplateVersionResult createServiceTemplateVersion(CreateServiceTemplateVersionRequest request) {
request = beforeClientExecution(request);
return executeCreateServiceTemplateVersion(request);
}
@SdkInternalApi
final CreateServiceTemplateVersionResult executeCreateServiceTemplateVersion(CreateServiceTemplateVersionRequest createServiceTemplateVersionRequest) {
ExecutionContext executionContext = createExecutionContext(createServiceTemplateVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateServiceTemplateVersionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createServiceTemplateVersionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateServiceTemplateVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateServiceTemplateVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Set up a template to create new template versions automatically by tracking a linked repository. A linked
* repository is a repository that has been registered with Proton. For more information, see
* CreateRepository.
*
*
* When a commit is pushed to your linked repository, Proton checks for changes to your repository template bundles.
* If it detects a template bundle change, a new major or minor version of its template is created, if the version
* doesn’t already exist. For more information, see Template sync
* configurations in the Proton User Guide.
*
*
* @param createTemplateSyncConfigRequest
* @return Result of the CreateTemplateSyncConfig operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.CreateTemplateSyncConfig
* @see AWS API Documentation
*/
@Override
public CreateTemplateSyncConfigResult createTemplateSyncConfig(CreateTemplateSyncConfigRequest request) {
request = beforeClientExecution(request);
return executeCreateTemplateSyncConfig(request);
}
@SdkInternalApi
final CreateTemplateSyncConfigResult executeCreateTemplateSyncConfig(CreateTemplateSyncConfigRequest createTemplateSyncConfigRequest) {
ExecutionContext executionContext = createExecutionContext(createTemplateSyncConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateTemplateSyncConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createTemplateSyncConfigRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateTemplateSyncConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateTemplateSyncConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Delete an Proton component resource.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
* @param deleteComponentRequest
* @return Result of the DeleteComponent operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteComponent
* @see AWS API
* Documentation
*/
@Override
public DeleteComponentResult deleteComponent(DeleteComponentRequest request) {
request = beforeClientExecution(request);
return executeDeleteComponent(request);
}
@SdkInternalApi
final DeleteComponentResult executeDeleteComponent(DeleteComponentRequest deleteComponentRequest) {
ExecutionContext executionContext = createExecutionContext(deleteComponentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteComponentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteComponentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteComponent");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteComponentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Delete the deployment.
*
*
* @param deleteDeploymentRequest
* @return Result of the DeleteDeployment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteDeployment
* @see AWS API
* Documentation
*/
@Override
public DeleteDeploymentResult deleteDeployment(DeleteDeploymentRequest request) {
request = beforeClientExecution(request);
return executeDeleteDeployment(request);
}
@SdkInternalApi
final DeleteDeploymentResult executeDeleteDeployment(DeleteDeploymentRequest deleteDeploymentRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDeploymentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDeploymentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteDeploymentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDeployment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteDeploymentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Delete an environment.
*
*
* @param deleteEnvironmentRequest
* @return Result of the DeleteEnvironment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteEnvironment
* @see AWS API
* Documentation
*/
@Override
public DeleteEnvironmentResult deleteEnvironment(DeleteEnvironmentRequest request) {
request = beforeClientExecution(request);
return executeDeleteEnvironment(request);
}
@SdkInternalApi
final DeleteEnvironmentResult executeDeleteEnvironment(DeleteEnvironmentRequest deleteEnvironmentRequest) {
ExecutionContext executionContext = createExecutionContext(deleteEnvironmentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteEnvironmentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteEnvironmentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteEnvironment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteEnvironmentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* In an environment account, delete an environment account connection.
*
*
* After you delete an environment account connection that’s in use by an Proton environment, Proton can’t
* manage the environment infrastructure resources until a new environment account connection is accepted for the
* environment account and associated environment. You're responsible for cleaning up provisioned resources that
* remain without an environment connection.
*
*
* For more information, see Environment account
* connections in the Proton User guide.
*
*
* @param deleteEnvironmentAccountConnectionRequest
* @return Result of the DeleteEnvironmentAccountConnection operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteEnvironmentAccountConnection
* @see AWS API Documentation
*/
@Override
public DeleteEnvironmentAccountConnectionResult deleteEnvironmentAccountConnection(DeleteEnvironmentAccountConnectionRequest request) {
request = beforeClientExecution(request);
return executeDeleteEnvironmentAccountConnection(request);
}
@SdkInternalApi
final DeleteEnvironmentAccountConnectionResult executeDeleteEnvironmentAccountConnection(
DeleteEnvironmentAccountConnectionRequest deleteEnvironmentAccountConnectionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteEnvironmentAccountConnectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteEnvironmentAccountConnectionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteEnvironmentAccountConnectionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteEnvironmentAccountConnection");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteEnvironmentAccountConnectionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* If no other major or minor versions of an environment template exist, delete the environment template.
*
*
* @param deleteEnvironmentTemplateRequest
* @return Result of the DeleteEnvironmentTemplate operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteEnvironmentTemplate
* @see AWS API Documentation
*/
@Override
public DeleteEnvironmentTemplateResult deleteEnvironmentTemplate(DeleteEnvironmentTemplateRequest request) {
request = beforeClientExecution(request);
return executeDeleteEnvironmentTemplate(request);
}
@SdkInternalApi
final DeleteEnvironmentTemplateResult executeDeleteEnvironmentTemplate(DeleteEnvironmentTemplateRequest deleteEnvironmentTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(deleteEnvironmentTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteEnvironmentTemplateRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteEnvironmentTemplateRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteEnvironmentTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteEnvironmentTemplateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* If no other minor versions of an environment template exist, delete a major version of the environment template
* if it's not the Recommended version. Delete the Recommended version of the environment
* template if no other major versions or minor versions of the environment template exist. A major version of an
* environment template is a version that's not backward compatible.
*
*
* Delete a minor version of an environment template if it isn't the Recommended version. Delete
* a Recommended minor version of the environment template if no other minor versions of the
* environment template exist. A minor version of an environment template is a version that's backward compatible.
*
*
* @param deleteEnvironmentTemplateVersionRequest
* @return Result of the DeleteEnvironmentTemplateVersion operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteEnvironmentTemplateVersion
* @see AWS API Documentation
*/
@Override
public DeleteEnvironmentTemplateVersionResult deleteEnvironmentTemplateVersion(DeleteEnvironmentTemplateVersionRequest request) {
request = beforeClientExecution(request);
return executeDeleteEnvironmentTemplateVersion(request);
}
@SdkInternalApi
final DeleteEnvironmentTemplateVersionResult executeDeleteEnvironmentTemplateVersion(
DeleteEnvironmentTemplateVersionRequest deleteEnvironmentTemplateVersionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteEnvironmentTemplateVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteEnvironmentTemplateVersionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteEnvironmentTemplateVersionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteEnvironmentTemplateVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteEnvironmentTemplateVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* De-register and unlink your repository.
*
*
* @param deleteRepositoryRequest
* @return Result of the DeleteRepository operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteRepository
* @see AWS API
* Documentation
*/
@Override
public DeleteRepositoryResult deleteRepository(DeleteRepositoryRequest request) {
request = beforeClientExecution(request);
return executeDeleteRepository(request);
}
@SdkInternalApi
final DeleteRepositoryResult executeDeleteRepository(DeleteRepositoryRequest deleteRepositoryRequest) {
ExecutionContext executionContext = createExecutionContext(deleteRepositoryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteRepositoryRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteRepositoryRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteRepository");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteRepositoryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Delete a service, with its instances and pipeline.
*
*
*
* You can't delete a service if it has any service instances that have components attached to them.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
*
* @param deleteServiceRequest
* @return Result of the DeleteService operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteService
* @see AWS API
* Documentation
*/
@Override
public DeleteServiceResult deleteService(DeleteServiceRequest request) {
request = beforeClientExecution(request);
return executeDeleteService(request);
}
@SdkInternalApi
final DeleteServiceResult executeDeleteService(DeleteServiceRequest deleteServiceRequest) {
ExecutionContext executionContext = createExecutionContext(deleteServiceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteServiceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteServiceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteService");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteServiceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Delete the Proton Ops file.
*
*
* @param deleteServiceSyncConfigRequest
* @return Result of the DeleteServiceSyncConfig operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteServiceSyncConfig
* @see AWS
* API Documentation
*/
@Override
public DeleteServiceSyncConfigResult deleteServiceSyncConfig(DeleteServiceSyncConfigRequest request) {
request = beforeClientExecution(request);
return executeDeleteServiceSyncConfig(request);
}
@SdkInternalApi
final DeleteServiceSyncConfigResult executeDeleteServiceSyncConfig(DeleteServiceSyncConfigRequest deleteServiceSyncConfigRequest) {
ExecutionContext executionContext = createExecutionContext(deleteServiceSyncConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteServiceSyncConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteServiceSyncConfigRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteServiceSyncConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteServiceSyncConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* If no other major or minor versions of the service template exist, delete the service template.
*
*
* @param deleteServiceTemplateRequest
* @return Result of the DeleteServiceTemplate operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteServiceTemplate
* @see AWS
* API Documentation
*/
@Override
public DeleteServiceTemplateResult deleteServiceTemplate(DeleteServiceTemplateRequest request) {
request = beforeClientExecution(request);
return executeDeleteServiceTemplate(request);
}
@SdkInternalApi
final DeleteServiceTemplateResult executeDeleteServiceTemplate(DeleteServiceTemplateRequest deleteServiceTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(deleteServiceTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteServiceTemplateRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteServiceTemplateRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteServiceTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteServiceTemplateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* If no other minor versions of a service template exist, delete a major version of the service template if it's
* not the Recommended version. Delete the Recommended version of the service template if
* no other major versions or minor versions of the service template exist. A major version of a service template is
* a version that isn't backwards compatible.
*
*
* Delete a minor version of a service template if it's not the Recommended version. Delete a
* Recommended minor version of the service template if no other minor versions of the service template
* exist. A minor version of a service template is a version that's backwards compatible.
*
*
* @param deleteServiceTemplateVersionRequest
* @return Result of the DeleteServiceTemplateVersion operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteServiceTemplateVersion
* @see AWS API Documentation
*/
@Override
public DeleteServiceTemplateVersionResult deleteServiceTemplateVersion(DeleteServiceTemplateVersionRequest request) {
request = beforeClientExecution(request);
return executeDeleteServiceTemplateVersion(request);
}
@SdkInternalApi
final DeleteServiceTemplateVersionResult executeDeleteServiceTemplateVersion(DeleteServiceTemplateVersionRequest deleteServiceTemplateVersionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteServiceTemplateVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteServiceTemplateVersionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteServiceTemplateVersionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteServiceTemplateVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteServiceTemplateVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Delete a template sync configuration.
*
*
* @param deleteTemplateSyncConfigRequest
* @return Result of the DeleteTemplateSyncConfig operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.DeleteTemplateSyncConfig
* @see AWS API Documentation
*/
@Override
public DeleteTemplateSyncConfigResult deleteTemplateSyncConfig(DeleteTemplateSyncConfigRequest request) {
request = beforeClientExecution(request);
return executeDeleteTemplateSyncConfig(request);
}
@SdkInternalApi
final DeleteTemplateSyncConfigResult executeDeleteTemplateSyncConfig(DeleteTemplateSyncConfigRequest deleteTemplateSyncConfigRequest) {
ExecutionContext executionContext = createExecutionContext(deleteTemplateSyncConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteTemplateSyncConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteTemplateSyncConfigRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteTemplateSyncConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteTemplateSyncConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detail data for Proton account-wide settings.
*
*
* @param getAccountSettingsRequest
* @return Result of the GetAccountSettings operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetAccountSettings
* @see AWS API
* Documentation
*/
@Override
public GetAccountSettingsResult getAccountSettings(GetAccountSettingsRequest request) {
request = beforeClientExecution(request);
return executeGetAccountSettings(request);
}
@SdkInternalApi
final GetAccountSettingsResult executeGetAccountSettings(GetAccountSettingsRequest getAccountSettingsRequest) {
ExecutionContext executionContext = createExecutionContext(getAccountSettingsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetAccountSettingsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getAccountSettingsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetAccountSettings");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetAccountSettingsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for a component.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
* @param getComponentRequest
* @return Result of the GetComponent operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetComponent
* @see AWS API
* Documentation
*/
@Override
public GetComponentResult getComponent(GetComponentRequest request) {
request = beforeClientExecution(request);
return executeGetComponent(request);
}
@SdkInternalApi
final GetComponentResult executeGetComponent(GetComponentRequest getComponentRequest) {
ExecutionContext executionContext = createExecutionContext(getComponentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetComponentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getComponentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetComponent");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetComponentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for a deployment.
*
*
* @param getDeploymentRequest
* @return Result of the GetDeployment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetDeployment
* @see AWS API
* Documentation
*/
@Override
public GetDeploymentResult getDeployment(GetDeploymentRequest request) {
request = beforeClientExecution(request);
return executeGetDeployment(request);
}
@SdkInternalApi
final GetDeploymentResult executeGetDeployment(GetDeploymentRequest getDeploymentRequest) {
ExecutionContext executionContext = createExecutionContext(getDeploymentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetDeploymentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getDeploymentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetDeployment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetDeploymentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for an environment.
*
*
* @param getEnvironmentRequest
* @return Result of the GetEnvironment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetEnvironment
* @see AWS API
* Documentation
*/
@Override
public GetEnvironmentResult getEnvironment(GetEnvironmentRequest request) {
request = beforeClientExecution(request);
return executeGetEnvironment(request);
}
@SdkInternalApi
final GetEnvironmentResult executeGetEnvironment(GetEnvironmentRequest getEnvironmentRequest) {
ExecutionContext executionContext = createExecutionContext(getEnvironmentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetEnvironmentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getEnvironmentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetEnvironment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetEnvironmentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* In an environment account, get the detailed data for an environment account connection.
*
*
* For more information, see Environment account
* connections in the Proton User guide.
*
*
* @param getEnvironmentAccountConnectionRequest
* @return Result of the GetEnvironmentAccountConnection operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetEnvironmentAccountConnection
* @see AWS API Documentation
*/
@Override
public GetEnvironmentAccountConnectionResult getEnvironmentAccountConnection(GetEnvironmentAccountConnectionRequest request) {
request = beforeClientExecution(request);
return executeGetEnvironmentAccountConnection(request);
}
@SdkInternalApi
final GetEnvironmentAccountConnectionResult executeGetEnvironmentAccountConnection(
GetEnvironmentAccountConnectionRequest getEnvironmentAccountConnectionRequest) {
ExecutionContext executionContext = createExecutionContext(getEnvironmentAccountConnectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetEnvironmentAccountConnectionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getEnvironmentAccountConnectionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetEnvironmentAccountConnection");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetEnvironmentAccountConnectionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for an environment template.
*
*
* @param getEnvironmentTemplateRequest
* @return Result of the GetEnvironmentTemplate operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetEnvironmentTemplate
* @see AWS
* API Documentation
*/
@Override
public GetEnvironmentTemplateResult getEnvironmentTemplate(GetEnvironmentTemplateRequest request) {
request = beforeClientExecution(request);
return executeGetEnvironmentTemplate(request);
}
@SdkInternalApi
final GetEnvironmentTemplateResult executeGetEnvironmentTemplate(GetEnvironmentTemplateRequest getEnvironmentTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(getEnvironmentTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetEnvironmentTemplateRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getEnvironmentTemplateRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetEnvironmentTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetEnvironmentTemplateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for a major or minor version of an environment template.
*
*
* @param getEnvironmentTemplateVersionRequest
* @return Result of the GetEnvironmentTemplateVersion operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetEnvironmentTemplateVersion
* @see AWS API Documentation
*/
@Override
public GetEnvironmentTemplateVersionResult getEnvironmentTemplateVersion(GetEnvironmentTemplateVersionRequest request) {
request = beforeClientExecution(request);
return executeGetEnvironmentTemplateVersion(request);
}
@SdkInternalApi
final GetEnvironmentTemplateVersionResult executeGetEnvironmentTemplateVersion(GetEnvironmentTemplateVersionRequest getEnvironmentTemplateVersionRequest) {
ExecutionContext executionContext = createExecutionContext(getEnvironmentTemplateVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetEnvironmentTemplateVersionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getEnvironmentTemplateVersionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetEnvironmentTemplateVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetEnvironmentTemplateVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detail data for a linked repository.
*
*
* @param getRepositoryRequest
* @return Result of the GetRepository operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetRepository
* @see AWS API
* Documentation
*/
@Override
public GetRepositoryResult getRepository(GetRepositoryRequest request) {
request = beforeClientExecution(request);
return executeGetRepository(request);
}
@SdkInternalApi
final GetRepositoryResult executeGetRepository(GetRepositoryRequest getRepositoryRequest) {
ExecutionContext executionContext = createExecutionContext(getRepositoryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetRepositoryRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getRepositoryRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetRepository");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetRepositoryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get the sync status of a repository used for Proton template sync. For more information about template sync, see
* .
*
*
*
* A repository sync status isn't tied to the Proton Repository resource (or any other Proton resource). Therefore,
* tags on an Proton Repository resource have no effect on this action. Specifically, you can't use these tags to
* control access to this action using Attribute-based access control (ABAC).
*
*
* For more information about ABAC, see ABAC in the Proton User Guide.
*
*
*
* @param getRepositorySyncStatusRequest
* @return Result of the GetRepositorySyncStatus operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetRepositorySyncStatus
* @see AWS
* API Documentation
*/
@Override
public GetRepositorySyncStatusResult getRepositorySyncStatus(GetRepositorySyncStatusRequest request) {
request = beforeClientExecution(request);
return executeGetRepositorySyncStatus(request);
}
@SdkInternalApi
final GetRepositorySyncStatusResult executeGetRepositorySyncStatus(GetRepositorySyncStatusRequest getRepositorySyncStatusRequest) {
ExecutionContext executionContext = createExecutionContext(getRepositorySyncStatusRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetRepositorySyncStatusRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getRepositorySyncStatusRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetRepositorySyncStatus");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetRepositorySyncStatusResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get counts of Proton resources.
*
*
* For infrastructure-provisioning resources (environments, services, service instances, pipelines), the action
* returns staleness counts. A resource is stale when it's behind the recommended version of the Proton template
* that it uses and it needs an update to become current.
*
*
* The action returns staleness counts (counts of resources that are up-to-date, behind a template major version, or
* behind a template minor version), the total number of resources, and the number of resources that are in a failed
* state, grouped by resource type. Components, environments, and service templates return less information - see
* the components, environments, and serviceTemplates field descriptions.
*
*
* For context, the action also returns the total number of each type of Proton template in the Amazon Web Services
* account.
*
*
* For more information, see Proton dashboard in the
* Proton User Guide.
*
*
* @param getResourcesSummaryRequest
* @return Result of the GetResourcesSummary operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetResourcesSummary
* @see AWS API
* Documentation
*/
@Override
public GetResourcesSummaryResult getResourcesSummary(GetResourcesSummaryRequest request) {
request = beforeClientExecution(request);
return executeGetResourcesSummary(request);
}
@SdkInternalApi
final GetResourcesSummaryResult executeGetResourcesSummary(GetResourcesSummaryRequest getResourcesSummaryRequest) {
ExecutionContext executionContext = createExecutionContext(getResourcesSummaryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetResourcesSummaryRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getResourcesSummaryRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetResourcesSummary");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetResourcesSummaryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for a service.
*
*
* @param getServiceRequest
* @return Result of the GetService operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetService
* @see AWS API
* Documentation
*/
@Override
public GetServiceResult getService(GetServiceRequest request) {
request = beforeClientExecution(request);
return executeGetService(request);
}
@SdkInternalApi
final GetServiceResult executeGetService(GetServiceRequest getServiceRequest) {
ExecutionContext executionContext = createExecutionContext(getServiceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetServiceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getServiceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetService");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetServiceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for a service instance. A service instance is an instantiation of service template and it runs
* in a specific environment.
*
*
* @param getServiceInstanceRequest
* @return Result of the GetServiceInstance operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetServiceInstance
* @see AWS API
* Documentation
*/
@Override
public GetServiceInstanceResult getServiceInstance(GetServiceInstanceRequest request) {
request = beforeClientExecution(request);
return executeGetServiceInstance(request);
}
@SdkInternalApi
final GetServiceInstanceResult executeGetServiceInstance(GetServiceInstanceRequest getServiceInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(getServiceInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetServiceInstanceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getServiceInstanceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetServiceInstance");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetServiceInstanceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get the status of the synced service instance.
*
*
* @param getServiceInstanceSyncStatusRequest
* @return Result of the GetServiceInstanceSyncStatus operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetServiceInstanceSyncStatus
* @see AWS API Documentation
*/
@Override
public GetServiceInstanceSyncStatusResult getServiceInstanceSyncStatus(GetServiceInstanceSyncStatusRequest request) {
request = beforeClientExecution(request);
return executeGetServiceInstanceSyncStatus(request);
}
@SdkInternalApi
final GetServiceInstanceSyncStatusResult executeGetServiceInstanceSyncStatus(GetServiceInstanceSyncStatusRequest getServiceInstanceSyncStatusRequest) {
ExecutionContext executionContext = createExecutionContext(getServiceInstanceSyncStatusRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetServiceInstanceSyncStatusRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getServiceInstanceSyncStatusRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetServiceInstanceSyncStatus");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetServiceInstanceSyncStatusResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for the service sync blocker summary.
*
*
* @param getServiceSyncBlockerSummaryRequest
* @return Result of the GetServiceSyncBlockerSummary operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetServiceSyncBlockerSummary
* @see AWS API Documentation
*/
@Override
public GetServiceSyncBlockerSummaryResult getServiceSyncBlockerSummary(GetServiceSyncBlockerSummaryRequest request) {
request = beforeClientExecution(request);
return executeGetServiceSyncBlockerSummary(request);
}
@SdkInternalApi
final GetServiceSyncBlockerSummaryResult executeGetServiceSyncBlockerSummary(GetServiceSyncBlockerSummaryRequest getServiceSyncBlockerSummaryRequest) {
ExecutionContext executionContext = createExecutionContext(getServiceSyncBlockerSummaryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetServiceSyncBlockerSummaryRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getServiceSyncBlockerSummaryRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetServiceSyncBlockerSummary");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetServiceSyncBlockerSummaryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed information for the service sync configuration.
*
*
* @param getServiceSyncConfigRequest
* @return Result of the GetServiceSyncConfig operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetServiceSyncConfig
* @see AWS
* API Documentation
*/
@Override
public GetServiceSyncConfigResult getServiceSyncConfig(GetServiceSyncConfigRequest request) {
request = beforeClientExecution(request);
return executeGetServiceSyncConfig(request);
}
@SdkInternalApi
final GetServiceSyncConfigResult executeGetServiceSyncConfig(GetServiceSyncConfigRequest getServiceSyncConfigRequest) {
ExecutionContext executionContext = createExecutionContext(getServiceSyncConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetServiceSyncConfigRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getServiceSyncConfigRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetServiceSyncConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetServiceSyncConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for a service template.
*
*
* @param getServiceTemplateRequest
* @return Result of the GetServiceTemplate operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetServiceTemplate
* @see AWS API
* Documentation
*/
@Override
public GetServiceTemplateResult getServiceTemplate(GetServiceTemplateRequest request) {
request = beforeClientExecution(request);
return executeGetServiceTemplate(request);
}
@SdkInternalApi
final GetServiceTemplateResult executeGetServiceTemplate(GetServiceTemplateRequest getServiceTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(getServiceTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetServiceTemplateRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getServiceTemplateRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetServiceTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetServiceTemplateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detailed data for a major or minor version of a service template.
*
*
* @param getServiceTemplateVersionRequest
* @return Result of the GetServiceTemplateVersion operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetServiceTemplateVersion
* @see AWS API Documentation
*/
@Override
public GetServiceTemplateVersionResult getServiceTemplateVersion(GetServiceTemplateVersionRequest request) {
request = beforeClientExecution(request);
return executeGetServiceTemplateVersion(request);
}
@SdkInternalApi
final GetServiceTemplateVersionResult executeGetServiceTemplateVersion(GetServiceTemplateVersionRequest getServiceTemplateVersionRequest) {
ExecutionContext executionContext = createExecutionContext(getServiceTemplateVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetServiceTemplateVersionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getServiceTemplateVersionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetServiceTemplateVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetServiceTemplateVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get detail data for a template sync configuration.
*
*
* @param getTemplateSyncConfigRequest
* @return Result of the GetTemplateSyncConfig operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetTemplateSyncConfig
* @see AWS
* API Documentation
*/
@Override
public GetTemplateSyncConfigResult getTemplateSyncConfig(GetTemplateSyncConfigRequest request) {
request = beforeClientExecution(request);
return executeGetTemplateSyncConfig(request);
}
@SdkInternalApi
final GetTemplateSyncConfigResult executeGetTemplateSyncConfig(GetTemplateSyncConfigRequest getTemplateSyncConfigRequest) {
ExecutionContext executionContext = createExecutionContext(getTemplateSyncConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetTemplateSyncConfigRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getTemplateSyncConfigRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetTemplateSyncConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetTemplateSyncConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get the status of a template sync.
*
*
* @param getTemplateSyncStatusRequest
* @return Result of the GetTemplateSyncStatus operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.GetTemplateSyncStatus
* @see AWS
* API Documentation
*/
@Override
public GetTemplateSyncStatusResult getTemplateSyncStatus(GetTemplateSyncStatusRequest request) {
request = beforeClientExecution(request);
return executeGetTemplateSyncStatus(request);
}
@SdkInternalApi
final GetTemplateSyncStatusResult executeGetTemplateSyncStatus(GetTemplateSyncStatusRequest getTemplateSyncStatusRequest) {
ExecutionContext executionContext = createExecutionContext(getTemplateSyncStatusRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetTemplateSyncStatusRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getTemplateSyncStatusRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetTemplateSyncStatus");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetTemplateSyncStatusResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get a list of component Infrastructure as Code (IaC) outputs.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
* @param listComponentOutputsRequest
* @return Result of the ListComponentOutputs operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListComponentOutputs
* @see AWS
* API Documentation
*/
@Override
public ListComponentOutputsResult listComponentOutputs(ListComponentOutputsRequest request) {
request = beforeClientExecution(request);
return executeListComponentOutputs(request);
}
@SdkInternalApi
final ListComponentOutputsResult executeListComponentOutputs(ListComponentOutputsRequest listComponentOutputsRequest) {
ExecutionContext executionContext = createExecutionContext(listComponentOutputsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListComponentOutputsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listComponentOutputsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListComponentOutputs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListComponentOutputsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List provisioned resources for a component with details.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
* @param listComponentProvisionedResourcesRequest
* @return Result of the ListComponentProvisionedResources operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListComponentProvisionedResources
* @see AWS API Documentation
*/
@Override
public ListComponentProvisionedResourcesResult listComponentProvisionedResources(ListComponentProvisionedResourcesRequest request) {
request = beforeClientExecution(request);
return executeListComponentProvisionedResources(request);
}
@SdkInternalApi
final ListComponentProvisionedResourcesResult executeListComponentProvisionedResources(
ListComponentProvisionedResourcesRequest listComponentProvisionedResourcesRequest) {
ExecutionContext executionContext = createExecutionContext(listComponentProvisionedResourcesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListComponentProvisionedResourcesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listComponentProvisionedResourcesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListComponentProvisionedResources");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListComponentProvisionedResourcesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List components with summary data. You can filter the result list by environment, service, or a single service
* instance.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
* @param listComponentsRequest
* @return Result of the ListComponents operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListComponents
* @see AWS API
* Documentation
*/
@Override
public ListComponentsResult listComponents(ListComponentsRequest request) {
request = beforeClientExecution(request);
return executeListComponents(request);
}
@SdkInternalApi
final ListComponentsResult executeListComponents(ListComponentsRequest listComponentsRequest) {
ExecutionContext executionContext = createExecutionContext(listComponentsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListComponentsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listComponentsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListComponents");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListComponentsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List deployments. You can filter the result list by environment, service, or a single service instance.
*
*
* @param listDeploymentsRequest
* @return Result of the ListDeployments operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListDeployments
* @see AWS API
* Documentation
*/
@Override
public ListDeploymentsResult listDeployments(ListDeploymentsRequest request) {
request = beforeClientExecution(request);
return executeListDeployments(request);
}
@SdkInternalApi
final ListDeploymentsResult executeListDeployments(ListDeploymentsRequest listDeploymentsRequest) {
ExecutionContext executionContext = createExecutionContext(listDeploymentsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDeploymentsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listDeploymentsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListDeployments");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListDeploymentsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* View a list of environment account connections.
*
*
* For more information, see Environment account
* connections in the Proton User guide.
*
*
* @param listEnvironmentAccountConnectionsRequest
* @return Result of the ListEnvironmentAccountConnections operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListEnvironmentAccountConnections
* @see AWS API Documentation
*/
@Override
public ListEnvironmentAccountConnectionsResult listEnvironmentAccountConnections(ListEnvironmentAccountConnectionsRequest request) {
request = beforeClientExecution(request);
return executeListEnvironmentAccountConnections(request);
}
@SdkInternalApi
final ListEnvironmentAccountConnectionsResult executeListEnvironmentAccountConnections(
ListEnvironmentAccountConnectionsRequest listEnvironmentAccountConnectionsRequest) {
ExecutionContext executionContext = createExecutionContext(listEnvironmentAccountConnectionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListEnvironmentAccountConnectionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listEnvironmentAccountConnectionsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListEnvironmentAccountConnections");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListEnvironmentAccountConnectionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List the infrastructure as code outputs for your environment.
*
*
* @param listEnvironmentOutputsRequest
* @return Result of the ListEnvironmentOutputs operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListEnvironmentOutputs
* @see AWS
* API Documentation
*/
@Override
public ListEnvironmentOutputsResult listEnvironmentOutputs(ListEnvironmentOutputsRequest request) {
request = beforeClientExecution(request);
return executeListEnvironmentOutputs(request);
}
@SdkInternalApi
final ListEnvironmentOutputsResult executeListEnvironmentOutputs(ListEnvironmentOutputsRequest listEnvironmentOutputsRequest) {
ExecutionContext executionContext = createExecutionContext(listEnvironmentOutputsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListEnvironmentOutputsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listEnvironmentOutputsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListEnvironmentOutputs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListEnvironmentOutputsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List the provisioned resources for your environment.
*
*
* @param listEnvironmentProvisionedResourcesRequest
* @return Result of the ListEnvironmentProvisionedResources operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListEnvironmentProvisionedResources
* @see AWS API Documentation
*/
@Override
public ListEnvironmentProvisionedResourcesResult listEnvironmentProvisionedResources(ListEnvironmentProvisionedResourcesRequest request) {
request = beforeClientExecution(request);
return executeListEnvironmentProvisionedResources(request);
}
@SdkInternalApi
final ListEnvironmentProvisionedResourcesResult executeListEnvironmentProvisionedResources(
ListEnvironmentProvisionedResourcesRequest listEnvironmentProvisionedResourcesRequest) {
ExecutionContext executionContext = createExecutionContext(listEnvironmentProvisionedResourcesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListEnvironmentProvisionedResourcesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listEnvironmentProvisionedResourcesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListEnvironmentProvisionedResources");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListEnvironmentProvisionedResourcesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List major or minor versions of an environment template with detail data.
*
*
* @param listEnvironmentTemplateVersionsRequest
* @return Result of the ListEnvironmentTemplateVersions operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListEnvironmentTemplateVersions
* @see AWS API Documentation
*/
@Override
public ListEnvironmentTemplateVersionsResult listEnvironmentTemplateVersions(ListEnvironmentTemplateVersionsRequest request) {
request = beforeClientExecution(request);
return executeListEnvironmentTemplateVersions(request);
}
@SdkInternalApi
final ListEnvironmentTemplateVersionsResult executeListEnvironmentTemplateVersions(
ListEnvironmentTemplateVersionsRequest listEnvironmentTemplateVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(listEnvironmentTemplateVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListEnvironmentTemplateVersionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listEnvironmentTemplateVersionsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListEnvironmentTemplateVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListEnvironmentTemplateVersionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List environment templates.
*
*
* @param listEnvironmentTemplatesRequest
* @return Result of the ListEnvironmentTemplates operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListEnvironmentTemplates
* @see AWS API Documentation
*/
@Override
public ListEnvironmentTemplatesResult listEnvironmentTemplates(ListEnvironmentTemplatesRequest request) {
request = beforeClientExecution(request);
return executeListEnvironmentTemplates(request);
}
@SdkInternalApi
final ListEnvironmentTemplatesResult executeListEnvironmentTemplates(ListEnvironmentTemplatesRequest listEnvironmentTemplatesRequest) {
ExecutionContext executionContext = createExecutionContext(listEnvironmentTemplatesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListEnvironmentTemplatesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listEnvironmentTemplatesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListEnvironmentTemplates");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListEnvironmentTemplatesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List environments with detail data summaries.
*
*
* @param listEnvironmentsRequest
* @return Result of the ListEnvironments operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListEnvironments
* @see AWS API
* Documentation
*/
@Override
public ListEnvironmentsResult listEnvironments(ListEnvironmentsRequest request) {
request = beforeClientExecution(request);
return executeListEnvironments(request);
}
@SdkInternalApi
final ListEnvironmentsResult executeListEnvironments(ListEnvironmentsRequest listEnvironmentsRequest) {
ExecutionContext executionContext = createExecutionContext(listEnvironmentsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListEnvironmentsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listEnvironmentsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListEnvironments");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListEnvironmentsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List linked repositories with detail data.
*
*
* @param listRepositoriesRequest
* @return Result of the ListRepositories operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListRepositories
* @see AWS API
* Documentation
*/
@Override
public ListRepositoriesResult listRepositories(ListRepositoriesRequest request) {
request = beforeClientExecution(request);
return executeListRepositories(request);
}
@SdkInternalApi
final ListRepositoriesResult executeListRepositories(ListRepositoriesRequest listRepositoriesRequest) {
ExecutionContext executionContext = createExecutionContext(listRepositoriesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListRepositoriesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listRepositoriesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListRepositories");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListRepositoriesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List repository sync definitions with detail data.
*
*
* @param listRepositorySyncDefinitionsRequest
* @return Result of the ListRepositorySyncDefinitions operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListRepositorySyncDefinitions
* @see AWS API Documentation
*/
@Override
public ListRepositorySyncDefinitionsResult listRepositorySyncDefinitions(ListRepositorySyncDefinitionsRequest request) {
request = beforeClientExecution(request);
return executeListRepositorySyncDefinitions(request);
}
@SdkInternalApi
final ListRepositorySyncDefinitionsResult executeListRepositorySyncDefinitions(ListRepositorySyncDefinitionsRequest listRepositorySyncDefinitionsRequest) {
ExecutionContext executionContext = createExecutionContext(listRepositorySyncDefinitionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListRepositorySyncDefinitionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listRepositorySyncDefinitionsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListRepositorySyncDefinitions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListRepositorySyncDefinitionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get a list service of instance Infrastructure as Code (IaC) outputs.
*
*
* @param listServiceInstanceOutputsRequest
* @return Result of the ListServiceInstanceOutputs operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListServiceInstanceOutputs
* @see AWS API Documentation
*/
@Override
public ListServiceInstanceOutputsResult listServiceInstanceOutputs(ListServiceInstanceOutputsRequest request) {
request = beforeClientExecution(request);
return executeListServiceInstanceOutputs(request);
}
@SdkInternalApi
final ListServiceInstanceOutputsResult executeListServiceInstanceOutputs(ListServiceInstanceOutputsRequest listServiceInstanceOutputsRequest) {
ExecutionContext executionContext = createExecutionContext(listServiceInstanceOutputsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServiceInstanceOutputsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listServiceInstanceOutputsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListServiceInstanceOutputs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListServiceInstanceOutputsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List provisioned resources for a service instance with details.
*
*
* @param listServiceInstanceProvisionedResourcesRequest
* @return Result of the ListServiceInstanceProvisionedResources operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListServiceInstanceProvisionedResources
* @see AWS API Documentation
*/
@Override
public ListServiceInstanceProvisionedResourcesResult listServiceInstanceProvisionedResources(ListServiceInstanceProvisionedResourcesRequest request) {
request = beforeClientExecution(request);
return executeListServiceInstanceProvisionedResources(request);
}
@SdkInternalApi
final ListServiceInstanceProvisionedResourcesResult executeListServiceInstanceProvisionedResources(
ListServiceInstanceProvisionedResourcesRequest listServiceInstanceProvisionedResourcesRequest) {
ExecutionContext executionContext = createExecutionContext(listServiceInstanceProvisionedResourcesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServiceInstanceProvisionedResourcesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listServiceInstanceProvisionedResourcesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListServiceInstanceProvisionedResources");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListServiceInstanceProvisionedResourcesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List service instances with summary data. This action lists service instances of all services in the Amazon Web
* Services account.
*
*
* @param listServiceInstancesRequest
* @return Result of the ListServiceInstances operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListServiceInstances
* @see AWS
* API Documentation
*/
@Override
public ListServiceInstancesResult listServiceInstances(ListServiceInstancesRequest request) {
request = beforeClientExecution(request);
return executeListServiceInstances(request);
}
@SdkInternalApi
final ListServiceInstancesResult executeListServiceInstances(ListServiceInstancesRequest listServiceInstancesRequest) {
ExecutionContext executionContext = createExecutionContext(listServiceInstancesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServiceInstancesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listServiceInstancesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListServiceInstances");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListServiceInstancesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Get a list of service pipeline Infrastructure as Code (IaC) outputs.
*
*
* @param listServicePipelineOutputsRequest
* @return Result of the ListServicePipelineOutputs operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListServicePipelineOutputs
* @see AWS API Documentation
*/
@Override
public ListServicePipelineOutputsResult listServicePipelineOutputs(ListServicePipelineOutputsRequest request) {
request = beforeClientExecution(request);
return executeListServicePipelineOutputs(request);
}
@SdkInternalApi
final ListServicePipelineOutputsResult executeListServicePipelineOutputs(ListServicePipelineOutputsRequest listServicePipelineOutputsRequest) {
ExecutionContext executionContext = createExecutionContext(listServicePipelineOutputsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServicePipelineOutputsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listServicePipelineOutputsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListServicePipelineOutputs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListServicePipelineOutputsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List provisioned resources for a service and pipeline with details.
*
*
* @param listServicePipelineProvisionedResourcesRequest
* @return Result of the ListServicePipelineProvisionedResources operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListServicePipelineProvisionedResources
* @see AWS API Documentation
*/
@Override
public ListServicePipelineProvisionedResourcesResult listServicePipelineProvisionedResources(ListServicePipelineProvisionedResourcesRequest request) {
request = beforeClientExecution(request);
return executeListServicePipelineProvisionedResources(request);
}
@SdkInternalApi
final ListServicePipelineProvisionedResourcesResult executeListServicePipelineProvisionedResources(
ListServicePipelineProvisionedResourcesRequest listServicePipelineProvisionedResourcesRequest) {
ExecutionContext executionContext = createExecutionContext(listServicePipelineProvisionedResourcesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServicePipelineProvisionedResourcesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listServicePipelineProvisionedResourcesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListServicePipelineProvisionedResources");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListServicePipelineProvisionedResourcesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List major or minor versions of a service template with detail data.
*
*
* @param listServiceTemplateVersionsRequest
* @return Result of the ListServiceTemplateVersions operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListServiceTemplateVersions
* @see AWS API Documentation
*/
@Override
public ListServiceTemplateVersionsResult listServiceTemplateVersions(ListServiceTemplateVersionsRequest request) {
request = beforeClientExecution(request);
return executeListServiceTemplateVersions(request);
}
@SdkInternalApi
final ListServiceTemplateVersionsResult executeListServiceTemplateVersions(ListServiceTemplateVersionsRequest listServiceTemplateVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(listServiceTemplateVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServiceTemplateVersionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listServiceTemplateVersionsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListServiceTemplateVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListServiceTemplateVersionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List service templates with detail data.
*
*
* @param listServiceTemplatesRequest
* @return Result of the ListServiceTemplates operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListServiceTemplates
* @see AWS
* API Documentation
*/
@Override
public ListServiceTemplatesResult listServiceTemplates(ListServiceTemplatesRequest request) {
request = beforeClientExecution(request);
return executeListServiceTemplates(request);
}
@SdkInternalApi
final ListServiceTemplatesResult executeListServiceTemplates(ListServiceTemplatesRequest listServiceTemplatesRequest) {
ExecutionContext executionContext = createExecutionContext(listServiceTemplatesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServiceTemplatesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listServiceTemplatesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListServiceTemplates");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListServiceTemplatesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List services with summaries of detail data.
*
*
* @param listServicesRequest
* @return Result of the ListServices operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListServices
* @see AWS API
* Documentation
*/
@Override
public ListServicesResult listServices(ListServicesRequest request) {
request = beforeClientExecution(request);
return executeListServices(request);
}
@SdkInternalApi
final ListServicesResult executeListServices(ListServicesRequest listServicesRequest) {
ExecutionContext executionContext = createExecutionContext(listServicesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServicesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listServicesRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListServices");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListServicesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List tags for a resource. For more information, see Proton resources and tagging in the
* Proton User Guide.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.ListTagsForResource
* @see AWS API
* Documentation
*/
@Override
public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) {
request = beforeClientExecution(request);
return executeListTagsForResource(request);
}
@SdkInternalApi
final ListTagsForResourceResult executeListTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest) {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTagsForResourceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTagsForResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Notify Proton of status changes to a provisioned resource when you use self-managed provisioning.
*
*
* For more information, see Self-managed provisioning in the Proton User Guide.
*
*
* @param notifyResourceDeploymentStatusChangeRequest
* @return Result of the NotifyResourceDeploymentStatusChange operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.NotifyResourceDeploymentStatusChange
* @see AWS API Documentation
*/
@Override
public NotifyResourceDeploymentStatusChangeResult notifyResourceDeploymentStatusChange(NotifyResourceDeploymentStatusChangeRequest request) {
request = beforeClientExecution(request);
return executeNotifyResourceDeploymentStatusChange(request);
}
@SdkInternalApi
final NotifyResourceDeploymentStatusChangeResult executeNotifyResourceDeploymentStatusChange(
NotifyResourceDeploymentStatusChangeRequest notifyResourceDeploymentStatusChangeRequest) {
ExecutionContext executionContext = createExecutionContext(notifyResourceDeploymentStatusChangeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new NotifyResourceDeploymentStatusChangeRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(notifyResourceDeploymentStatusChangeRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "NotifyResourceDeploymentStatusChange");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new NotifyResourceDeploymentStatusChangeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* In a management account, reject an environment account connection from another environment account.
*
*
* After you reject an environment account connection request, you can't accept or use the rejected
* environment account connection.
*
*
* You can’t reject an environment account connection that's connected to an environment.
*
*
* For more information, see Environment account
* connections in the Proton User guide.
*
*
* @param rejectEnvironmentAccountConnectionRequest
* @return Result of the RejectEnvironmentAccountConnection operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.RejectEnvironmentAccountConnection
* @see AWS API Documentation
*/
@Override
public RejectEnvironmentAccountConnectionResult rejectEnvironmentAccountConnection(RejectEnvironmentAccountConnectionRequest request) {
request = beforeClientExecution(request);
return executeRejectEnvironmentAccountConnection(request);
}
@SdkInternalApi
final RejectEnvironmentAccountConnectionResult executeRejectEnvironmentAccountConnection(
RejectEnvironmentAccountConnectionRequest rejectEnvironmentAccountConnectionRequest) {
ExecutionContext executionContext = createExecutionContext(rejectEnvironmentAccountConnectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RejectEnvironmentAccountConnectionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(rejectEnvironmentAccountConnectionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RejectEnvironmentAccountConnection");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RejectEnvironmentAccountConnectionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Tag a resource. A tag is a key-value pair of metadata that you associate with an Proton resource.
*
*
* For more information, see Proton
* resources and tagging in the Proton User Guide.
*
*
* @param tagResourceRequest
* @return Result of the TagResource operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.TagResource
* @see AWS API
* Documentation
*/
@Override
public TagResourceResult tagResource(TagResourceRequest request) {
request = beforeClientExecution(request);
return executeTagResource(request);
}
@SdkInternalApi
final TagResourceResult executeTagResource(TagResourceRequest tagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(tagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(tagResourceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Remove a customer tag from a resource. A tag is a key-value pair of metadata associated with an Proton resource.
*
*
* For more information, see Proton
* resources and tagging in the Proton User Guide.
*
*
* @param untagResourceRequest
* @return Result of the UntagResource operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UntagResource
* @see AWS API
* Documentation
*/
@Override
public UntagResourceResult untagResource(UntagResourceRequest request) {
request = beforeClientExecution(request);
return executeUntagResource(request);
}
@SdkInternalApi
final UntagResourceResult executeUntagResource(UntagResourceRequest untagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(untagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(untagResourceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UntagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update Proton settings that are used for multiple services in the Amazon Web Services account.
*
*
* @param updateAccountSettingsRequest
* @return Result of the UpdateAccountSettings operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateAccountSettings
* @see AWS
* API Documentation
*/
@Override
public UpdateAccountSettingsResult updateAccountSettings(UpdateAccountSettingsRequest request) {
request = beforeClientExecution(request);
return executeUpdateAccountSettings(request);
}
@SdkInternalApi
final UpdateAccountSettingsResult executeUpdateAccountSettings(UpdateAccountSettingsRequest updateAccountSettingsRequest) {
ExecutionContext executionContext = createExecutionContext(updateAccountSettingsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateAccountSettingsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateAccountSettingsRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateAccountSettings");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateAccountSettingsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update a component.
*
*
* There are a few modes for updating a component. The deploymentType field defines the mode.
*
*
*
* You can't update a component while its deployment status, or the deployment status of a service instance attached
* to it, is IN_PROGRESS.
*
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
* @param updateComponentRequest
* @return Result of the UpdateComponent operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateComponent
* @see AWS API
* Documentation
*/
@Override
public UpdateComponentResult updateComponent(UpdateComponentRequest request) {
request = beforeClientExecution(request);
return executeUpdateComponent(request);
}
@SdkInternalApi
final UpdateComponentResult executeUpdateComponent(UpdateComponentRequest updateComponentRequest) {
ExecutionContext executionContext = createExecutionContext(updateComponentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateComponentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateComponentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateComponent");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateComponentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update an environment.
*
*
* If the environment is associated with an environment account connection, don't update or include the
* protonServiceRoleArn and provisioningRepository parameter to update or connect to an
* environment account connection.
*
*
* You can only update to a new environment account connection if that connection was created in the same
* environment account that the current environment account connection was created in. The account connection must
* also be associated with the current environment.
*
*
* If the environment isn't associated with an environment account connection, don't update or include
* the environmentAccountConnectionId parameter. You can't update or connect the environment to
* an environment account connection if it isn't already associated with an environment connection.
*
*
* You can update either the environmentAccountConnectionId or protonServiceRoleArn
* parameter and value. You can’t update both.
*
*
* If the environment was configured for Amazon Web Services-managed provisioning, omit the
* provisioningRepository parameter.
*
*
* If the environment was configured for self-managed provisioning, specify the provisioningRepository
* parameter and omit the protonServiceRoleArn and environmentAccountConnectionId
* parameters.
*
*
* For more information, see Environments and Provisioning methods in
* the Proton User Guide.
*
*
* There are four modes for updating an environment. The deploymentType field defines the mode.
*
*
*
* -
*
* NONE
*
*
* In this mode, a deployment doesn't occur. Only the requested metadata parameters are updated.
*
*
*
* -
*
* CURRENT_VERSION
*
*
* In this mode, the environment is deployed and updated with the new spec that you provide. Only requested
* parameters are updated. Don’t include minor or major version parameters when you use this
* deployment-type.
*
*
*
* -
*
* MINOR_VERSION
*
*
* In this mode, the environment is deployed and updated with the published, recommended (latest) minor version of
* the current major version in use, by default. You can also specify a different minor version of the current major
* version in use.
*
*
*
* -
*
* MAJOR_VERSION
*
*
* In this mode, the environment is deployed and updated with the published, recommended (latest) major and minor
* version of the current template, by default. You can also specify a different major version that's higher than
* the major version in use and a minor version.
*
*
*
*
* @param updateEnvironmentRequest
* @return Result of the UpdateEnvironment operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateEnvironment
* @see AWS API
* Documentation
*/
@Override
public UpdateEnvironmentResult updateEnvironment(UpdateEnvironmentRequest request) {
request = beforeClientExecution(request);
return executeUpdateEnvironment(request);
}
@SdkInternalApi
final UpdateEnvironmentResult executeUpdateEnvironment(UpdateEnvironmentRequest updateEnvironmentRequest) {
ExecutionContext executionContext = createExecutionContext(updateEnvironmentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateEnvironmentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateEnvironmentRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateEnvironment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateEnvironmentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* In an environment account, update an environment account connection to use a new IAM role.
*
*
* For more information, see Environment account
* connections in the Proton User guide.
*
*
* @param updateEnvironmentAccountConnectionRequest
* @return Result of the UpdateEnvironmentAccountConnection operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateEnvironmentAccountConnection
* @see AWS API Documentation
*/
@Override
public UpdateEnvironmentAccountConnectionResult updateEnvironmentAccountConnection(UpdateEnvironmentAccountConnectionRequest request) {
request = beforeClientExecution(request);
return executeUpdateEnvironmentAccountConnection(request);
}
@SdkInternalApi
final UpdateEnvironmentAccountConnectionResult executeUpdateEnvironmentAccountConnection(
UpdateEnvironmentAccountConnectionRequest updateEnvironmentAccountConnectionRequest) {
ExecutionContext executionContext = createExecutionContext(updateEnvironmentAccountConnectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateEnvironmentAccountConnectionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateEnvironmentAccountConnectionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateEnvironmentAccountConnection");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateEnvironmentAccountConnectionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update an environment template.
*
*
* @param updateEnvironmentTemplateRequest
* @return Result of the UpdateEnvironmentTemplate operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateEnvironmentTemplate
* @see AWS API Documentation
*/
@Override
public UpdateEnvironmentTemplateResult updateEnvironmentTemplate(UpdateEnvironmentTemplateRequest request) {
request = beforeClientExecution(request);
return executeUpdateEnvironmentTemplate(request);
}
@SdkInternalApi
final UpdateEnvironmentTemplateResult executeUpdateEnvironmentTemplate(UpdateEnvironmentTemplateRequest updateEnvironmentTemplateRequest) {
ExecutionContext executionContext = createExecutionContext(updateEnvironmentTemplateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateEnvironmentTemplateRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateEnvironmentTemplateRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateEnvironmentTemplate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateEnvironmentTemplateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update a major or minor version of an environment template.
*
*
* @param updateEnvironmentTemplateVersionRequest
* @return Result of the UpdateEnvironmentTemplateVersion operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateEnvironmentTemplateVersion
* @see AWS API Documentation
*/
@Override
public UpdateEnvironmentTemplateVersionResult updateEnvironmentTemplateVersion(UpdateEnvironmentTemplateVersionRequest request) {
request = beforeClientExecution(request);
return executeUpdateEnvironmentTemplateVersion(request);
}
@SdkInternalApi
final UpdateEnvironmentTemplateVersionResult executeUpdateEnvironmentTemplateVersion(
UpdateEnvironmentTemplateVersionRequest updateEnvironmentTemplateVersionRequest) {
ExecutionContext executionContext = createExecutionContext(updateEnvironmentTemplateVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateEnvironmentTemplateVersionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateEnvironmentTemplateVersionRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateEnvironmentTemplateVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateEnvironmentTemplateVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Edit a service description or use a spec to add and delete service instances.
*
*
*
* Existing service instances and the service pipeline can't be edited using this API. They can only be
* deleted.
*
*
*
* Use the description parameter to modify the description.
*
*
* Edit the spec parameter to add or delete instances.
*
*
*
* You can't delete a service instance (remove it from the spec) if it has an attached component.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
*
* @param updateServiceRequest
* @return Result of the UpdateService operation returned by the service.
* @throws ServiceQuotaExceededException
* A quota was exceeded. For more information, see Proton Quotas in the
* Proton User Guide.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateService
* @see AWS API
* Documentation
*/
@Override
public UpdateServiceResult updateService(UpdateServiceRequest request) {
request = beforeClientExecution(request);
return executeUpdateService(request);
}
@SdkInternalApi
final UpdateServiceResult executeUpdateService(UpdateServiceRequest updateServiceRequest) {
ExecutionContext executionContext = createExecutionContext(updateServiceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateServiceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateServiceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateService");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateServiceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update a service instance.
*
*
* There are a few modes for updating a service instance. The deploymentType field defines the mode.
*
*
*
* You can't update a service instance while its deployment status, or the deployment status of a component attached
* to it, is IN_PROGRESS.
*
*
* For more information about components, see Proton components in the
* Proton User Guide.
*
*
*
* @param updateServiceInstanceRequest
* @return Result of the UpdateServiceInstance operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateServiceInstance
* @see AWS
* API Documentation
*/
@Override
public UpdateServiceInstanceResult updateServiceInstance(UpdateServiceInstanceRequest request) {
request = beforeClientExecution(request);
return executeUpdateServiceInstance(request);
}
@SdkInternalApi
final UpdateServiceInstanceResult executeUpdateServiceInstance(UpdateServiceInstanceRequest updateServiceInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(updateServiceInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateServiceInstanceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateServiceInstanceRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateServiceInstance");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateServiceInstanceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update the service pipeline.
*
*
* There are four modes for updating a service pipeline. The deploymentType field defines the mode.
*
*
*
* -
*
* NONE
*
*
* In this mode, a deployment doesn't occur. Only the requested metadata parameters are updated.
*
*
*
* -
*
* CURRENT_VERSION
*
*
* In this mode, the service pipeline is deployed and updated with the new spec that you provide. Only requested
* parameters are updated. Don’t include major or minor version parameters when you use this
* deployment-type.
*
*
*
* -
*
* MINOR_VERSION
*
*
* In this mode, the service pipeline is deployed and updated with the published, recommended (latest) minor version
* of the current major version in use, by default. You can specify a different minor version of the current major
* version in use.
*
*
*
* -
*
* MAJOR_VERSION
*
*
* In this mode, the service pipeline is deployed and updated with the published, recommended (latest) major and
* minor version of the current template by default. You can specify a different major version that's higher than
* the major version in use and a minor version.
*
*
*
*
* @param updateServicePipelineRequest
* @return Result of the UpdateServicePipeline operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateServicePipeline
* @see AWS
* API Documentation
*/
@Override
public UpdateServicePipelineResult updateServicePipeline(UpdateServicePipelineRequest request) {
request = beforeClientExecution(request);
return executeUpdateServicePipeline(request);
}
@SdkInternalApi
final UpdateServicePipelineResult executeUpdateServicePipeline(UpdateServicePipelineRequest updateServicePipelineRequest) {
ExecutionContext executionContext = createExecutionContext(updateServicePipelineRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateServicePipelineRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateServicePipelineRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateServicePipeline");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateServicePipelineResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update the service sync blocker by resolving it.
*
*
* @param updateServiceSyncBlockerRequest
* @return Result of the UpdateServiceSyncBlocker operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateServiceSyncBlocker
* @see AWS API Documentation
*/
@Override
public UpdateServiceSyncBlockerResult updateServiceSyncBlocker(UpdateServiceSyncBlockerRequest request) {
request = beforeClientExecution(request);
return executeUpdateServiceSyncBlocker(request);
}
@SdkInternalApi
final UpdateServiceSyncBlockerResult executeUpdateServiceSyncBlocker(UpdateServiceSyncBlockerRequest updateServiceSyncBlockerRequest) {
ExecutionContext executionContext = createExecutionContext(updateServiceSyncBlockerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateServiceSyncBlockerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateServiceSyncBlockerRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateServiceSyncBlocker");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateServiceSyncBlockerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update the Proton Ops config file.
*
*
* @param updateServiceSyncConfigRequest
* @return Result of the UpdateServiceSyncConfig operation returned by the service.
* @throws ValidationException
* The input is invalid or an out-of-range value was supplied for the input parameter.
* @throws AccessDeniedException
* There isn't sufficient access for performing this action.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ConflictException
* The request couldn't be made due to a conflicting operation or resource.
* @throws ResourceNotFoundException
* The requested resource wasn't found.
* @throws InternalServerException
* The request failed to register with the service.
* @sample AWSProton.UpdateServiceSyncConfig
* @see AWS
* API Documentation
*/
@Override
public UpdateServiceSyncConfigResult updateServiceSyncConfig(UpdateServiceSyncConfigRequest request) {
request = beforeClientExecution(request);
return executeUpdateServiceSyncConfig(request);
}
@SdkInternalApi
final UpdateServiceSyncConfigResult executeUpdateServiceSyncConfig(UpdateServiceSyncConfigRequest updateServiceSyncConfigRequest) {
ExecutionContext executionContext = createExecutionContext(updateServiceSyncConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateServiceSyncConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateServiceSyncConfigRequest));
// 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, "Proton");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateServiceSyncConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateServiceSyncConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*