File Coverage

blib/lib/Paws/Batch.pm
Criterion Covered Total %
statement 3 3 100.0
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 4 4 100.0


line stmt bran cond sub pod time code
1             package Paws::Batch;
2 1     1   927 use Moose;
  1         2  
  1         8  
3             sub service { 'batch' }
4             sub version { '2016-08-10' }
5             sub flattened_arrays { 0 }
6             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
7             has retry => (is => 'ro', isa => 'HashRef', default => sub {
8             { base => 'rand', type => 'exponential', growth_factor => 2 }
9             });
10             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
11             ] });
12              
13             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller', 'Paws::Net::RestJsonResponse';
14              
15            
16             sub CancelJob {
17             my $self = shift;
18             my $call_object = $self->new_with_coercions('Paws::Batch::CancelJob', @_);
19             return $self->caller->do_call($self, $call_object);
20             }
21             sub CreateComputeEnvironment {
22             my $self = shift;
23             my $call_object = $self->new_with_coercions('Paws::Batch::CreateComputeEnvironment', @_);
24             return $self->caller->do_call($self, $call_object);
25             }
26             sub CreateJobQueue {
27             my $self = shift;
28             my $call_object = $self->new_with_coercions('Paws::Batch::CreateJobQueue', @_);
29             return $self->caller->do_call($self, $call_object);
30             }
31             sub DeleteComputeEnvironment {
32             my $self = shift;
33             my $call_object = $self->new_with_coercions('Paws::Batch::DeleteComputeEnvironment', @_);
34             return $self->caller->do_call($self, $call_object);
35             }
36             sub DeleteJobQueue {
37             my $self = shift;
38             my $call_object = $self->new_with_coercions('Paws::Batch::DeleteJobQueue', @_);
39             return $self->caller->do_call($self, $call_object);
40             }
41             sub DeregisterJobDefinition {
42             my $self = shift;
43             my $call_object = $self->new_with_coercions('Paws::Batch::DeregisterJobDefinition', @_);
44             return $self->caller->do_call($self, $call_object);
45             }
46             sub DescribeComputeEnvironments {
47             my $self = shift;
48             my $call_object = $self->new_with_coercions('Paws::Batch::DescribeComputeEnvironments', @_);
49             return $self->caller->do_call($self, $call_object);
50             }
51             sub DescribeJobDefinitions {
52             my $self = shift;
53             my $call_object = $self->new_with_coercions('Paws::Batch::DescribeJobDefinitions', @_);
54             return $self->caller->do_call($self, $call_object);
55             }
56             sub DescribeJobQueues {
57             my $self = shift;
58             my $call_object = $self->new_with_coercions('Paws::Batch::DescribeJobQueues', @_);
59             return $self->caller->do_call($self, $call_object);
60             }
61             sub DescribeJobs {
62             my $self = shift;
63             my $call_object = $self->new_with_coercions('Paws::Batch::DescribeJobs', @_);
64             return $self->caller->do_call($self, $call_object);
65             }
66             sub ListJobs {
67             my $self = shift;
68             my $call_object = $self->new_with_coercions('Paws::Batch::ListJobs', @_);
69             return $self->caller->do_call($self, $call_object);
70             }
71             sub RegisterJobDefinition {
72             my $self = shift;
73             my $call_object = $self->new_with_coercions('Paws::Batch::RegisterJobDefinition', @_);
74             return $self->caller->do_call($self, $call_object);
75             }
76             sub SubmitJob {
77             my $self = shift;
78             my $call_object = $self->new_with_coercions('Paws::Batch::SubmitJob', @_);
79             return $self->caller->do_call($self, $call_object);
80             }
81             sub TerminateJob {
82             my $self = shift;
83             my $call_object = $self->new_with_coercions('Paws::Batch::TerminateJob', @_);
84             return $self->caller->do_call($self, $call_object);
85             }
86             sub UpdateComputeEnvironment {
87             my $self = shift;
88             my $call_object = $self->new_with_coercions('Paws::Batch::UpdateComputeEnvironment', @_);
89             return $self->caller->do_call($self, $call_object);
90             }
91             sub UpdateJobQueue {
92             my $self = shift;
93             my $call_object = $self->new_with_coercions('Paws::Batch::UpdateJobQueue', @_);
94             return $self->caller->do_call($self, $call_object);
95             }
96            
97              
98              
99             sub operations { qw/CancelJob CreateComputeEnvironment CreateJobQueue DeleteComputeEnvironment DeleteJobQueue DeregisterJobDefinition DescribeComputeEnvironments DescribeJobDefinitions DescribeJobQueues DescribeJobs ListJobs RegisterJobDefinition SubmitJob TerminateJob UpdateComputeEnvironment UpdateJobQueue / }
100              
101             1;
102              
103             ### main pod documentation begin ###
104              
105             =head1 NAME
106              
107             Paws::Batch - Perl Interface to AWS AWS Batch
108              
109             =head1 SYNOPSIS
110              
111             use Paws;
112              
113             my $obj = Paws->service('Batch');
114             my $res = $obj->Method(
115             Arg1 => $val1,
116             Arg2 => [ 'V1', 'V2' ],
117             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
118             # of the arguments type
119             Arg3 => { Att1 => 'Val1' },
120             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
121             # the constructor of the arguments type
122             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
123             );
124              
125             =head1 DESCRIPTION
126              
127             AWS Batch enables you to run batch computing workloads on the AWS
128             Cloud. Batch computing is a common way for developers, scientists, and
129             engineers to access large amounts of compute resources, and AWS Batch
130             removes the undifferentiated heavy lifting of configuring and managing
131             the required infrastructure. AWS Batch will be familiar to users of
132             traditional batch computing software. This service can efficiently
133             provision resources in response to jobs submitted in order to eliminate
134             capacity constraints, reduce compute costs, and deliver results
135             quickly.
136              
137             As a fully managed service, AWS Batch enables developers, scientists,
138             and engineers to run batch computing workloads of any scale. AWS Batch
139             automatically provisions compute resources and optimizes the workload
140             distribution based on the quantity and scale of the workloads. With AWS
141             Batch, there is no need to install or manage batch computing software,
142             which allows you to focus on analyzing results and solving problems.
143             AWS Batch reduces operational complexities, saves time, and reduces
144             costs, which makes it easy for developers, scientists, and engineers to
145             run their batch jobs in the AWS Cloud.
146              
147             =head1 METHODS
148              
149             =head2 CancelJob(JobId => Str, Reason => Str)
150              
151             Each argument is described in detail in: L<Paws::Batch::CancelJob>
152              
153             Returns: a L<Paws::Batch::CancelJobResponse> instance
154              
155             Cancels jobs in an AWS Batch job queue. Jobs that are in the
156             C<SUBMITTED>, C<PENDING>, or C<RUNNABLE> state are cancelled. Jobs that
157             have progressed to C<STARTING> or C<RUNNING> are not cancelled (but the
158             API operation still succeeds, even if no jobs are cancelled); these
159             jobs must be terminated with the TerminateJob operation.
160              
161              
162             =head2 CreateComputeEnvironment(ComputeEnvironmentName => Str, ServiceRole => Str, Type => Str, [ComputeResources => L<Paws::Batch::ComputeResource>, State => Str])
163              
164             Each argument is described in detail in: L<Paws::Batch::CreateComputeEnvironment>
165              
166             Returns: a L<Paws::Batch::CreateComputeEnvironmentResponse> instance
167              
168             Creates an AWS Batch compute environment. You can create C<MANAGED> or
169             C<UNMANAGED> compute environments.
170              
171             In a managed compute environment, AWS Batch manages the compute
172             resources within the environment, based on the compute resources that
173             you specify. Instances launched into a managed compute environment use
174             a recent, approved version of the Amazon ECS-optimized AMI. You can
175             choose to use Amazon EC2 On-Demand instances in your managed compute
176             environment, or you can use Amazon EC2 Spot instances that only launch
177             when the Spot bid price is below a specified percentage of the
178             On-Demand price.
179              
180             In an unmanaged compute environment, you can manage your own compute
181             resources. This provides more compute resource configuration options,
182             such as using a custom AMI, but you must ensure that your AMI meets the
183             Amazon ECS container instance AMI specification. For more information,
184             see Container Instance AMIs in the I<Amazon EC2 Container Service
185             Developer Guide>. After you have created your unmanaged compute
186             environment, you can use the DescribeComputeEnvironments operation to
187             find the Amazon ECS cluster that is associated with it and then
188             manually launch your container instances into that Amazon ECS cluster.
189             For more information, see Launching an Amazon ECS Container Instance in
190             the I<Amazon EC2 Container Service Developer Guide>.
191              
192              
193             =head2 CreateJobQueue(ComputeEnvironmentOrder => ArrayRef[L<Paws::Batch::ComputeEnvironmentOrder>], JobQueueName => Str, Priority => Int, [State => Str])
194              
195             Each argument is described in detail in: L<Paws::Batch::CreateJobQueue>
196              
197             Returns: a L<Paws::Batch::CreateJobQueueResponse> instance
198              
199             Creates an AWS Batch job queue. When you create a job queue, you
200             associate one or more compute environments to the queue and assign an
201             order of preference for the compute environments.
202              
203             You also set a priority to the job queue that determines the order in
204             which the AWS Batch scheduler places jobs onto its associated compute
205             environments. For example, if a compute environment is associated with
206             more than one job queue, the job queue with a higher priority is given
207             preference for scheduling jobs to that compute environment.
208              
209              
210             =head2 DeleteComputeEnvironment(ComputeEnvironment => Str)
211              
212             Each argument is described in detail in: L<Paws::Batch::DeleteComputeEnvironment>
213              
214             Returns: a L<Paws::Batch::DeleteComputeEnvironmentResponse> instance
215              
216             Deletes an AWS Batch compute environment.
217              
218             Before you can delete a compute environment, you must set its state to
219             C<DISABLED> with the UpdateComputeEnvironment API operation and
220             disassociate it from any job queues with the UpdateJobQueue API
221             operation.
222              
223              
224             =head2 DeleteJobQueue(JobQueue => Str)
225              
226             Each argument is described in detail in: L<Paws::Batch::DeleteJobQueue>
227              
228             Returns: a L<Paws::Batch::DeleteJobQueueResponse> instance
229              
230             Deletes the specified job queue. You must first disable submissions for
231             a queue with the UpdateJobQueue operation. All jobs in the queue are
232             terminated when you delete a job queue.
233              
234             It is not necessary to disassociate compute environments from a queue
235             before submitting a C<DeleteJobQueue> request.
236              
237              
238             =head2 DeregisterJobDefinition(JobDefinition => Str)
239              
240             Each argument is described in detail in: L<Paws::Batch::DeregisterJobDefinition>
241              
242             Returns: a L<Paws::Batch::DeregisterJobDefinitionResponse> instance
243              
244             Deregisters an AWS Batch job definition.
245              
246              
247             =head2 DescribeComputeEnvironments([ComputeEnvironments => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
248              
249             Each argument is described in detail in: L<Paws::Batch::DescribeComputeEnvironments>
250              
251             Returns: a L<Paws::Batch::DescribeComputeEnvironmentsResponse> instance
252              
253             Describes one or more of your compute environments.
254              
255             If you are using an unmanaged compute environment, you can use the
256             C<DescribeComputeEnvironment> operation to determine the
257             C<ecsClusterArn> that you should launch your Amazon ECS container
258             instances into.
259              
260              
261             =head2 DescribeJobDefinitions([JobDefinitionName => Str, JobDefinitions => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str, Status => Str])
262              
263             Each argument is described in detail in: L<Paws::Batch::DescribeJobDefinitions>
264              
265             Returns: a L<Paws::Batch::DescribeJobDefinitionsResponse> instance
266              
267             Describes a list of job definitions. You can specify a C<status> (such
268             as C<ACTIVE>) to only return job definitions that match that status.
269              
270              
271             =head2 DescribeJobQueues([JobQueues => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
272              
273             Each argument is described in detail in: L<Paws::Batch::DescribeJobQueues>
274              
275             Returns: a L<Paws::Batch::DescribeJobQueuesResponse> instance
276              
277             Describes one or more of your job queues.
278              
279              
280             =head2 DescribeJobs(Jobs => ArrayRef[Str|Undef])
281              
282             Each argument is described in detail in: L<Paws::Batch::DescribeJobs>
283              
284             Returns: a L<Paws::Batch::DescribeJobsResponse> instance
285              
286             Describes a list of AWS Batch jobs.
287              
288              
289             =head2 ListJobs(JobQueue => Str, [JobStatus => Str, MaxResults => Int, NextToken => Str])
290              
291             Each argument is described in detail in: L<Paws::Batch::ListJobs>
292              
293             Returns: a L<Paws::Batch::ListJobsResponse> instance
294              
295             Returns a list of task jobs for a specified job queue. You can filter
296             the results by job status with the C<jobStatus> parameter. If you do
297             not specify a status, only C<RUNNING> jobs are returned.
298              
299              
300             =head2 RegisterJobDefinition(JobDefinitionName => Str, Type => Str, [ContainerProperties => L<Paws::Batch::ContainerProperties>, Parameters => L<Paws::Batch::ParametersMap>, RetryStrategy => L<Paws::Batch::RetryStrategy>])
301              
302             Each argument is described in detail in: L<Paws::Batch::RegisterJobDefinition>
303              
304             Returns: a L<Paws::Batch::RegisterJobDefinitionResponse> instance
305              
306             Registers an AWS Batch job definition.
307              
308              
309             =head2 SubmitJob(JobDefinition => Str, JobName => Str, JobQueue => Str, [ContainerOverrides => L<Paws::Batch::ContainerOverrides>, DependsOn => ArrayRef[L<Paws::Batch::JobDependency>], Parameters => L<Paws::Batch::ParametersMap>, RetryStrategy => L<Paws::Batch::RetryStrategy>])
310              
311             Each argument is described in detail in: L<Paws::Batch::SubmitJob>
312              
313             Returns: a L<Paws::Batch::SubmitJobResponse> instance
314              
315             Submits an AWS Batch job from a job definition. Parameters specified
316             during SubmitJob override parameters defined in the job definition.
317              
318              
319             =head2 TerminateJob(JobId => Str, Reason => Str)
320              
321             Each argument is described in detail in: L<Paws::Batch::TerminateJob>
322              
323             Returns: a L<Paws::Batch::TerminateJobResponse> instance
324              
325             Terminates jobs in a job queue. Jobs that are in the C<STARTING> or
326             C<RUNNING> state are terminated, which causes them to transition to
327             C<FAILED>. Jobs that have not progressed to the C<STARTING> state are
328             cancelled.
329              
330              
331             =head2 UpdateComputeEnvironment(ComputeEnvironment => Str, [ComputeResources => L<Paws::Batch::ComputeResourceUpdate>, ServiceRole => Str, State => Str])
332              
333             Each argument is described in detail in: L<Paws::Batch::UpdateComputeEnvironment>
334              
335             Returns: a L<Paws::Batch::UpdateComputeEnvironmentResponse> instance
336              
337             Updates an AWS Batch compute environment.
338              
339              
340             =head2 UpdateJobQueue(JobQueue => Str, [ComputeEnvironmentOrder => ArrayRef[L<Paws::Batch::ComputeEnvironmentOrder>], Priority => Int, State => Str])
341              
342             Each argument is described in detail in: L<Paws::Batch::UpdateJobQueue>
343              
344             Returns: a L<Paws::Batch::UpdateJobQueueResponse> instance
345              
346             Updates a job queue.
347              
348              
349              
350              
351             =head1 PAGINATORS
352              
353             Paginator methods are helpers that repetively call methods that return partial results
354              
355              
356              
357              
358             =head1 SEE ALSO
359              
360             This service class forms part of L<Paws>
361              
362             =head1 BUGS and CONTRIBUTIONS
363              
364             The source code is located here: https://github.com/pplu/aws-sdk-perl
365              
366             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
367              
368             =cut
369