com.amazonaws.services.batch.AWSBatchClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-batch Show documentation
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.batch;
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.batch.AWSBatchClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.batch.model.*;
import com.amazonaws.services.batch.model.transform.*;
/**
* Client for accessing AWS Batch. All service calls made using this client are blocking, and will not return until the
* service call completes.
*
* Batch
*
* Using Batch, you can run batch computing workloads on the Amazon Web Services Cloud. Batch computing is a common
* means for developers, scientists, and engineers to access large amounts of compute resources. Batch uses the
* advantages of the batch computing to remove the undifferentiated heavy lifting of configuring and managing required
* infrastructure. At the same time, it also adopts a familiar batch computing software approach. You can use Batch to
* efficiently provision resources, and work toward eliminating capacity constraints, reducing your overall compute
* costs, and delivering results more quickly.
*
*
* As a fully managed service, Batch can run batch computing workloads of any scale. Batch automatically provisions
* compute resources and optimizes workload distribution based on the quantity and scale of your specific workloads.
* With Batch, there's no need to install or manage batch computing software. This means that you can focus on analyzing
* results and solving your specific problems instead.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSBatchClient extends AmazonWebServiceClient implements AWSBatch {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AWSBatch.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "batch";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.withContentTypeOverride("application/json")
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServerException").withExceptionUnmarshaller(
com.amazonaws.services.batch.model.transform.ServerExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ClientException").withExceptionUnmarshaller(
com.amazonaws.services.batch.model.transform.ClientExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.batch.model.AWSBatchException.class));
/**
* Constructs a new client to invoke service methods on AWS Batch. A credentials provider chain will be used that
* searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AWSBatchClientBuilder#defaultClient()}
*/
@Deprecated
public AWSBatchClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on AWS Batch. A credentials provider chain will be used that
* searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to AWS Batch (ex: proxy settings,
* retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AWSBatchClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSBatchClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on AWS Batch using the specified AWS account credentials.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @deprecated use {@link AWSBatchClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AWSBatchClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
public AWSBatchClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on AWS Batch using the specified AWS account credentials and
* client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to AWS Batch (ex: proxy settings,
* retry counts, etc.).
* @deprecated use {@link AWSBatchClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSBatchClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSBatchClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
/**
* Constructs a new client to invoke service methods on AWS Batch using the specified AWS account credentials
* provider.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @deprecated use {@link AWSBatchClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AWSBatchClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on AWS Batch using the specified AWS account credentials
* provider and client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to AWS Batch (ex: proxy settings,
* retry counts, etc.).
* @deprecated use {@link AWSBatchClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSBatchClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSBatchClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on AWS Batch using the specified AWS account credentials
* provider, client configuration options, and request metric collector.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to AWS Batch (ex: proxy settings,
* retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
* @deprecated use {@link AWSBatchClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSBatchClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AWSBatchClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AWSBatchClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
public static AWSBatchClientBuilder builder() {
return AWSBatchClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on AWS Batch 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.
*/
AWSBatchClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on AWS Batch 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.
*/
AWSBatchClient(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("batch.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/batch/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/batch/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Cancels a job in an Batch job queue. Jobs that are in the SUBMITTED or PENDING are
* canceled. A job inRUNNABLE remains in RUNNABLE until it reaches the head of the job
* queue. Then the job status is updated to FAILED.
*
*
*
* A PENDING job is canceled after all dependency jobs are completed. Therefore, it may take longer
* than expected to cancel a job in PENDING status.
*
*
* When you try to cancel an array parent job in PENDING, Batch attempts to cancel all child jobs. The
* array parent job is canceled when all child jobs are completed.
*
*
*
* Jobs that progressed to the STARTING or RUNNING state aren't canceled. However, the API
* operation still succeeds, even if no job is canceled. These jobs must be terminated with the TerminateJob
* operation.
*
*
* @param cancelJobRequest
* Contains the parameters for CancelJob.
* @return Result of the CancelJob operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.CancelJob
* @see AWS API
* Documentation
*/
@Override
public CancelJobResult cancelJob(CancelJobRequest request) {
request = beforeClientExecution(request);
return executeCancelJob(request);
}
@SdkInternalApi
final CancelJobResult executeCancelJob(CancelJobRequest cancelJobRequest) {
ExecutionContext executionContext = createExecutionContext(cancelJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelJobRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(cancelJobRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new CancelJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Batch compute environment. You can create MANAGED or UNMANAGED compute
* environments. MANAGED compute environments can use Amazon EC2 or Fargate resources.
* UNMANAGED compute environments can only use EC2 resources.
*
*
* In a managed compute environment, Batch manages the capacity and instance types of the compute resources within
* the environment. This is based on the compute resource specification that you define or the launch template that you
* specify when you create the compute environment. Either, you can choose to use EC2 On-Demand Instances and EC2
* Spot Instances. Or, you can use Fargate and Fargate Spot capacity in your managed compute environment. You can
* optionally set a maximum price so that Spot Instances only launch when the Spot Instance price is less than a
* specified percentage of the On-Demand price.
*
*
*
* Multi-node parallel jobs aren't supported on Spot Instances.
*
*
*
* In an unmanaged compute environment, you can manage your own EC2 compute resources and have flexibility with how
* you configure your compute resources. For example, you can use custom AMIs. However, you must verify that each of
* your AMIs meet the Amazon ECS container instance AMI specification. For more information, see container
* instance AMIs in the Amazon Elastic Container Service Developer Guide. After you created your
* unmanaged compute environment, you can use the DescribeComputeEnvironments operation to find the Amazon
* ECS cluster that's associated with it. Then, launch your container instances into that Amazon ECS cluster. For
* more information, see Launching an
* Amazon ECS container instance in the Amazon Elastic Container Service Developer Guide.
*
*
*
* To create a compute environment that uses EKS resources, the caller must have permissions to call
* eks:DescribeCluster.
*
*
*
* Batch doesn't automatically upgrade the AMIs in a compute environment after it's created. For example, it also
* doesn't update the AMIs in your compute environment when a newer version of the Amazon ECS optimized AMI is
* available. You're responsible for the management of the guest operating system. This includes any updates and
* security patches. You're also responsible for any additional application software or utilities that you install
* on the compute resources. There are two ways to use a new AMI for your Batch jobs. The original method is to
* complete these steps:
*
*
* -
*
* Create a new compute environment with the new AMI.
*
*
* -
*
* Add the compute environment to an existing job queue.
*
*
* -
*
* Remove the earlier compute environment from your job queue.
*
*
* -
*
* Delete the earlier compute environment.
*
*
*
*
* In April 2022, Batch added enhanced support for updating compute environments. For more information, see Updating compute
* environments. To use the enhanced updating of compute environments to update AMIs, follow these rules:
*
*
* -
*
* Either don't set the service role (serviceRole) parameter or set it to the
* AWSBatchServiceRole service-linked role.
*
*
* -
*
* Set the allocation strategy (allocationStrategy) parameter to BEST_FIT_PROGRESSIVE,
* SPOT_CAPACITY_OPTIMIZED, or SPOT_PRICE_CAPACITY_OPTIMIZED.
*
*
* -
*
* Set the update to latest image version (updateToLatestImageVersion) parameter to true.
* The updateToLatestImageVersion parameter is used when you update a compute environment. This
* parameter is ignored when you create a compute environment.
*
*
* -
*
* Don't specify an AMI ID in imageId, imageIdOverride (in
* ec2Configuration ), or in the launch template (launchTemplate). In that case, Batch
* selects the latest Amazon ECS optimized AMI that's supported by Batch at the time the infrastructure update is
* initiated. Alternatively, you can specify the AMI ID in the imageId or imageIdOverride
* parameters, or the launch template identified by the LaunchTemplate properties. Changing any of
* these properties starts an infrastructure update. If the AMI ID is specified in the launch template, it can't be
* replaced by specifying an AMI ID in either the imageId or imageIdOverride parameters.
* It can only be replaced by specifying a different launch template, or if the launch template version is set to
* $Default or $Latest, by setting either a new default version for the launch template
* (if $Default) or by adding a new version to the launch template (if $Latest).
*
*
*
*
* If these rules are followed, any update that starts an infrastructure update causes the AMI ID to be re-selected.
* If the version setting in the launch template (launchTemplate) is set to
* $Latest or $Default, the latest or default version of the launch template is evaluated
* up at the time of the infrastructure update, even if the launchTemplate wasn't updated.
*
*
*
* @param createComputeEnvironmentRequest
* Contains the parameters for CreateComputeEnvironment.
* @return Result of the CreateComputeEnvironment operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.CreateComputeEnvironment
* @see AWS
* API Documentation
*/
@Override
public CreateComputeEnvironmentResult createComputeEnvironment(CreateComputeEnvironmentRequest request) {
request = beforeClientExecution(request);
return executeCreateComputeEnvironment(request);
}
@SdkInternalApi
final CreateComputeEnvironmentResult executeCreateComputeEnvironment(CreateComputeEnvironmentRequest createComputeEnvironmentRequest) {
ExecutionContext executionContext = createExecutionContext(createComputeEnvironmentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateComputeEnvironmentRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createComputeEnvironmentRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateComputeEnvironment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateComputeEnvironmentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Batch job queue. When you create a job queue, you associate one or more compute environments to the
* queue and assign an order of preference for the compute environments.
*
*
* You also set a priority to the job queue that determines the order that the Batch scheduler places jobs onto its
* associated compute environments. For example, if a compute environment is associated with more than one job
* queue, the job queue with a higher priority is given preference for scheduling jobs to that compute environment.
*
*
* @param createJobQueueRequest
* Contains the parameters for CreateJobQueue.
* @return Result of the CreateJobQueue operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.CreateJobQueue
* @see AWS API
* Documentation
*/
@Override
public CreateJobQueueResult createJobQueue(CreateJobQueueRequest request) {
request = beforeClientExecution(request);
return executeCreateJobQueue(request);
}
@SdkInternalApi
final CreateJobQueueResult executeCreateJobQueue(CreateJobQueueRequest createJobQueueRequest) {
ExecutionContext executionContext = createExecutionContext(createJobQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateJobQueueRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createJobQueueRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateJobQueue");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateJobQueueResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Batch scheduling policy.
*
*
* @param createSchedulingPolicyRequest
* Contains the parameters for CreateSchedulingPolicy.
* @return Result of the CreateSchedulingPolicy operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.CreateSchedulingPolicy
* @see AWS
* API Documentation
*/
@Override
public CreateSchedulingPolicyResult createSchedulingPolicy(CreateSchedulingPolicyRequest request) {
request = beforeClientExecution(request);
return executeCreateSchedulingPolicy(request);
}
@SdkInternalApi
final CreateSchedulingPolicyResult executeCreateSchedulingPolicy(CreateSchedulingPolicyRequest createSchedulingPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(createSchedulingPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateSchedulingPolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createSchedulingPolicyRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateSchedulingPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateSchedulingPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Batch compute environment.
*
*
* Before you can delete a compute environment, you must set its state to DISABLED with the
* UpdateComputeEnvironment API operation and disassociate it from any job queues with the
* UpdateJobQueue API operation. Compute environments that use Fargate resources must terminate all active
* jobs on that compute environment before deleting the compute environment. If this isn't done, the compute
* environment enters an invalid state.
*
*
* @param deleteComputeEnvironmentRequest
* Contains the parameters for DeleteComputeEnvironment.
* @return Result of the DeleteComputeEnvironment operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DeleteComputeEnvironment
* @see AWS
* API Documentation
*/
@Override
public DeleteComputeEnvironmentResult deleteComputeEnvironment(DeleteComputeEnvironmentRequest request) {
request = beforeClientExecution(request);
return executeDeleteComputeEnvironment(request);
}
@SdkInternalApi
final DeleteComputeEnvironmentResult executeDeleteComputeEnvironment(DeleteComputeEnvironmentRequest deleteComputeEnvironmentRequest) {
ExecutionContext executionContext = createExecutionContext(deleteComputeEnvironmentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteComputeEnvironmentRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteComputeEnvironmentRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteComputeEnvironment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteComputeEnvironmentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified job queue. You must first disable submissions for a queue with the UpdateJobQueue
* operation. All jobs in the queue are eventually terminated when you delete a job queue. The jobs are terminated
* at a rate of about 16 jobs each second.
*
*
* It's not necessary to disassociate compute environments from a queue before submitting a
* DeleteJobQueue request.
*
*
* @param deleteJobQueueRequest
* Contains the parameters for DeleteJobQueue.
* @return Result of the DeleteJobQueue operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DeleteJobQueue
* @see AWS API
* Documentation
*/
@Override
public DeleteJobQueueResult deleteJobQueue(DeleteJobQueueRequest request) {
request = beforeClientExecution(request);
return executeDeleteJobQueue(request);
}
@SdkInternalApi
final DeleteJobQueueResult executeDeleteJobQueue(DeleteJobQueueRequest deleteJobQueueRequest) {
ExecutionContext executionContext = createExecutionContext(deleteJobQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteJobQueueRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteJobQueueRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteJobQueue");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteJobQueueResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified scheduling policy.
*
*
* You can't delete a scheduling policy that's used in any job queues.
*
*
* @param deleteSchedulingPolicyRequest
* Contains the parameters for DeleteSchedulingPolicy.
* @return Result of the DeleteSchedulingPolicy operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DeleteSchedulingPolicy
* @see AWS
* API Documentation
*/
@Override
public DeleteSchedulingPolicyResult deleteSchedulingPolicy(DeleteSchedulingPolicyRequest request) {
request = beforeClientExecution(request);
return executeDeleteSchedulingPolicy(request);
}
@SdkInternalApi
final DeleteSchedulingPolicyResult executeDeleteSchedulingPolicy(DeleteSchedulingPolicyRequest deleteSchedulingPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(deleteSchedulingPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteSchedulingPolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteSchedulingPolicyRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteSchedulingPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteSchedulingPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deregisters an Batch job definition. Job definitions are permanently deleted after 180 days.
*
*
* @param deregisterJobDefinitionRequest
* @return Result of the DeregisterJobDefinition operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DeregisterJobDefinition
* @see AWS
* API Documentation
*/
@Override
public DeregisterJobDefinitionResult deregisterJobDefinition(DeregisterJobDefinitionRequest request) {
request = beforeClientExecution(request);
return executeDeregisterJobDefinition(request);
}
@SdkInternalApi
final DeregisterJobDefinitionResult executeDeregisterJobDefinition(DeregisterJobDefinitionRequest deregisterJobDefinitionRequest) {
ExecutionContext executionContext = createExecutionContext(deregisterJobDefinitionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeregisterJobDefinitionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deregisterJobDefinitionRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeregisterJobDefinition");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeregisterJobDefinitionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes one or more of your compute environments.
*
*
* If you're using an unmanaged compute environment, you can use the DescribeComputeEnvironment
* operation to determine the ecsClusterArn that you launch your Amazon ECS container instances into.
*
*
* @param describeComputeEnvironmentsRequest
* Contains the parameters for DescribeComputeEnvironments.
* @return Result of the DescribeComputeEnvironments operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DescribeComputeEnvironments
* @see AWS API Documentation
*/
@Override
public DescribeComputeEnvironmentsResult describeComputeEnvironments(DescribeComputeEnvironmentsRequest request) {
request = beforeClientExecution(request);
return executeDescribeComputeEnvironments(request);
}
@SdkInternalApi
final DescribeComputeEnvironmentsResult executeDescribeComputeEnvironments(DescribeComputeEnvironmentsRequest describeComputeEnvironmentsRequest) {
ExecutionContext executionContext = createExecutionContext(describeComputeEnvironmentsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeComputeEnvironmentsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeComputeEnvironmentsRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeComputeEnvironments");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeComputeEnvironmentsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a list of job definitions. You can specify a status (such as ACTIVE) to only
* return job definitions that match that status.
*
*
* @param describeJobDefinitionsRequest
* Contains the parameters for DescribeJobDefinitions.
* @return Result of the DescribeJobDefinitions operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DescribeJobDefinitions
* @see AWS
* API Documentation
*/
@Override
public DescribeJobDefinitionsResult describeJobDefinitions(DescribeJobDefinitionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeJobDefinitions(request);
}
@SdkInternalApi
final DescribeJobDefinitionsResult executeDescribeJobDefinitions(DescribeJobDefinitionsRequest describeJobDefinitionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeJobDefinitionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeJobDefinitionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeJobDefinitionsRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeJobDefinitions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeJobDefinitionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes one or more of your job queues.
*
*
* @param describeJobQueuesRequest
* Contains the parameters for DescribeJobQueues.
* @return Result of the DescribeJobQueues operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DescribeJobQueues
* @see AWS API
* Documentation
*/
@Override
public DescribeJobQueuesResult describeJobQueues(DescribeJobQueuesRequest request) {
request = beforeClientExecution(request);
return executeDescribeJobQueues(request);
}
@SdkInternalApi
final DescribeJobQueuesResult executeDescribeJobQueues(DescribeJobQueuesRequest describeJobQueuesRequest) {
ExecutionContext executionContext = createExecutionContext(describeJobQueuesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeJobQueuesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeJobQueuesRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeJobQueues");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeJobQueuesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a list of Batch jobs.
*
*
* @param describeJobsRequest
* Contains the parameters for DescribeJobs.
* @return Result of the DescribeJobs operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DescribeJobs
* @see AWS API
* Documentation
*/
@Override
public DescribeJobsResult describeJobs(DescribeJobsRequest request) {
request = beforeClientExecution(request);
return executeDescribeJobs(request);
}
@SdkInternalApi
final DescribeJobsResult executeDescribeJobs(DescribeJobsRequest describeJobsRequest) {
ExecutionContext executionContext = createExecutionContext(describeJobsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeJobsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeJobsRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeJobs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeJobsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes one or more of your scheduling policies.
*
*
* @param describeSchedulingPoliciesRequest
* Contains the parameters for DescribeSchedulingPolicies.
* @return Result of the DescribeSchedulingPolicies operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.DescribeSchedulingPolicies
* @see AWS API Documentation
*/
@Override
public DescribeSchedulingPoliciesResult describeSchedulingPolicies(DescribeSchedulingPoliciesRequest request) {
request = beforeClientExecution(request);
return executeDescribeSchedulingPolicies(request);
}
@SdkInternalApi
final DescribeSchedulingPoliciesResult executeDescribeSchedulingPolicies(DescribeSchedulingPoliciesRequest describeSchedulingPoliciesRequest) {
ExecutionContext executionContext = createExecutionContext(describeSchedulingPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeSchedulingPoliciesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeSchedulingPoliciesRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeSchedulingPolicies");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeSchedulingPoliciesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides a list of the first 100 RUNNABLE jobs associated to a single job queue.
*
*
* @param getJobQueueSnapshotRequest
* @return Result of the GetJobQueueSnapshot operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.GetJobQueueSnapshot
* @see AWS API
* Documentation
*/
@Override
public GetJobQueueSnapshotResult getJobQueueSnapshot(GetJobQueueSnapshotRequest request) {
request = beforeClientExecution(request);
return executeGetJobQueueSnapshot(request);
}
@SdkInternalApi
final GetJobQueueSnapshotResult executeGetJobQueueSnapshot(GetJobQueueSnapshotRequest getJobQueueSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(getJobQueueSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetJobQueueSnapshotRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getJobQueueSnapshotRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetJobQueueSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetJobQueueSnapshotResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of Batch jobs.
*
*
* You must specify only one of the following items:
*
*
* -
*
* A job queue ID to return a list of jobs in that job queue
*
*
* -
*
* A multi-node parallel job ID to return a list of nodes for that job
*
*
* -
*
* An array job ID to return a list of the children for that job
*
*
*
*
* You can filter the results by job status with the jobStatus parameter. If you don't specify a
* status, only RUNNING jobs are returned.
*
*
* @param listJobsRequest
* Contains the parameters for ListJobs.
* @return Result of the ListJobs operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.ListJobs
* @see AWS API
* Documentation
*/
@Override
public ListJobsResult listJobs(ListJobsRequest request) {
request = beforeClientExecution(request);
return executeListJobs(request);
}
@SdkInternalApi
final ListJobsResult executeListJobs(ListJobsRequest listJobsRequest) {
ExecutionContext executionContext = createExecutionContext(listJobsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListJobsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listJobsRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListJobs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListJobsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of Batch scheduling policies.
*
*
* @param listSchedulingPoliciesRequest
* Contains the parameters for ListSchedulingPolicies.
* @return Result of the ListSchedulingPolicies operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.ListSchedulingPolicies
* @see AWS
* API Documentation
*/
@Override
public ListSchedulingPoliciesResult listSchedulingPolicies(ListSchedulingPoliciesRequest request) {
request = beforeClientExecution(request);
return executeListSchedulingPolicies(request);
}
@SdkInternalApi
final ListSchedulingPoliciesResult executeListSchedulingPolicies(ListSchedulingPoliciesRequest listSchedulingPoliciesRequest) {
ExecutionContext executionContext = createExecutionContext(listSchedulingPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListSchedulingPoliciesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listSchedulingPoliciesRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListSchedulingPolicies");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListSchedulingPoliciesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the tags for an Batch resource. Batch resources that support tags are compute environments, jobs, job
* definitions, job queues, and scheduling policies. ARNs for child jobs of array and multi-node parallel (MNP) jobs
* aren't supported.
*
*
* @param listTagsForResourceRequest
* Contains the parameters for ListTagsForResource.
* @return Result of the ListTagsForResource operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.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, "Batch");
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);
}
}
/**
*
* Registers an Batch job definition.
*
*
* @param registerJobDefinitionRequest
* Contains the parameters for RegisterJobDefinition.
* @return Result of the RegisterJobDefinition operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.RegisterJobDefinition
* @see AWS
* API Documentation
*/
@Override
public RegisterJobDefinitionResult registerJobDefinition(RegisterJobDefinitionRequest request) {
request = beforeClientExecution(request);
return executeRegisterJobDefinition(request);
}
@SdkInternalApi
final RegisterJobDefinitionResult executeRegisterJobDefinition(RegisterJobDefinitionRequest registerJobDefinitionRequest) {
ExecutionContext executionContext = createExecutionContext(registerJobDefinitionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RegisterJobDefinitionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(registerJobDefinitionRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RegisterJobDefinition");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RegisterJobDefinitionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Submits an Batch job from a job definition. Parameters that are specified during SubmitJob override
* parameters defined in the job definition. vCPU and memory requirements that are specified in the
* resourceRequirements objects in the job definition are the exception. They can't be overridden this
* way using the memory and vcpus parameters. Rather, you must specify updates to job
* definition parameters in a resourceRequirements object that's included in the
* containerOverrides parameter.
*
*
*
* Job queues with a scheduling policy are limited to 500 active fair share identifiers at a time.
*
*
*
* Jobs that run on Fargate resources can't be guaranteed to run for more than 14 days. This is because, after 14
* days, Fargate resources might become unavailable and job might be terminated.
*
*
*
* @param submitJobRequest
* Contains the parameters for SubmitJob.
* @return Result of the SubmitJob operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.SubmitJob
* @see AWS API
* Documentation
*/
@Override
public SubmitJobResult submitJob(SubmitJobRequest request) {
request = beforeClientExecution(request);
return executeSubmitJob(request);
}
@SdkInternalApi
final SubmitJobResult executeSubmitJob(SubmitJobRequest submitJobRequest) {
ExecutionContext executionContext = createExecutionContext(submitJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SubmitJobRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(submitJobRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SubmitJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new SubmitJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates the specified tags to a resource with the specified resourceArn. If existing tags on a
* resource aren't specified in the request parameters, they aren't changed. When a resource is deleted, the tags
* that are associated with that resource are deleted as well. Batch resources that support tags are compute
* environments, jobs, job definitions, job queues, and scheduling policies. ARNs for child jobs of array and
* multi-node parallel (MNP) jobs aren't supported.
*
*
* @param tagResourceRequest
* Contains the parameters for TagResource.
* @return Result of the TagResource operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.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, "Batch");
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);
}
}
/**
*
* Terminates a job in a job queue. Jobs that are in the STARTING or RUNNING state are
* terminated, which causes them to transition to FAILED. Jobs that have not progressed to the
* STARTING state are cancelled.
*
*
* @param terminateJobRequest
* Contains the parameters for TerminateJob.
* @return Result of the TerminateJob operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.TerminateJob
* @see AWS API
* Documentation
*/
@Override
public TerminateJobResult terminateJob(TerminateJobRequest request) {
request = beforeClientExecution(request);
return executeTerminateJob(request);
}
@SdkInternalApi
final TerminateJobResult executeTerminateJob(TerminateJobRequest terminateJobRequest) {
ExecutionContext executionContext = createExecutionContext(terminateJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TerminateJobRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(terminateJobRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TerminateJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TerminateJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes specified tags from an Batch resource.
*
*
* @param untagResourceRequest
* Contains the parameters for UntagResource.
* @return Result of the UntagResource operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.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, "Batch");
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);
}
}
/**
*
* Updates an Batch compute environment.
*
*
* @param updateComputeEnvironmentRequest
* Contains the parameters for UpdateComputeEnvironment.
* @return Result of the UpdateComputeEnvironment operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.UpdateComputeEnvironment
* @see AWS
* API Documentation
*/
@Override
public UpdateComputeEnvironmentResult updateComputeEnvironment(UpdateComputeEnvironmentRequest request) {
request = beforeClientExecution(request);
return executeUpdateComputeEnvironment(request);
}
@SdkInternalApi
final UpdateComputeEnvironmentResult executeUpdateComputeEnvironment(UpdateComputeEnvironmentRequest updateComputeEnvironmentRequest) {
ExecutionContext executionContext = createExecutionContext(updateComputeEnvironmentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateComputeEnvironmentRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateComputeEnvironmentRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateComputeEnvironment");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateComputeEnvironmentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a job queue.
*
*
* @param updateJobQueueRequest
* Contains the parameters for UpdateJobQueue.
* @return Result of the UpdateJobQueue operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.UpdateJobQueue
* @see AWS API
* Documentation
*/
@Override
public UpdateJobQueueResult updateJobQueue(UpdateJobQueueRequest request) {
request = beforeClientExecution(request);
return executeUpdateJobQueue(request);
}
@SdkInternalApi
final UpdateJobQueueResult executeUpdateJobQueue(UpdateJobQueueRequest updateJobQueueRequest) {
ExecutionContext executionContext = createExecutionContext(updateJobQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateJobQueueRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateJobQueueRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateJobQueue");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateJobQueueResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a scheduling policy.
*
*
* @param updateSchedulingPolicyRequest
* Contains the parameters for UpdateSchedulingPolicy.
* @return Result of the UpdateSchedulingPolicy operation returned by the service.
* @throws ClientException
* These errors are usually caused by a client action. One example cause is using an action or resource on
* behalf of a user that doesn't have permissions to use the action or resource. Another cause is specifying
* an identifier that's not valid.
* @throws ServerException
* These errors are usually caused by a server issue.
* @sample AWSBatch.UpdateSchedulingPolicy
* @see AWS
* API Documentation
*/
@Override
public UpdateSchedulingPolicyResult updateSchedulingPolicy(UpdateSchedulingPolicyRequest request) {
request = beforeClientExecution(request);
return executeUpdateSchedulingPolicy(request);
}
@SdkInternalApi
final UpdateSchedulingPolicyResult executeUpdateSchedulingPolicy(UpdateSchedulingPolicyRequest updateSchedulingPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(updateSchedulingPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateSchedulingPolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateSchedulingPolicyRequest));
// 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, "Batch");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateSchedulingPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateSchedulingPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
@Override
public void shutdown() {
super.shutdown();
}
}