File Coverage

blib/lib/Paws/OpsWorksCM.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::OpsWorksCM;
2 1     1   8436 use Moose;
  1         2  
  1         11  
3             sub service { 'opsworks-cm' }
4             sub version { '2016-11-01' }
5             sub target_prefix { 'OpsWorksCM_V2016_11_01' }
6             sub json_version { "1.1" }
7             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8             has retry => (is => 'ro', isa => 'HashRef', default => sub {
9             { base => 'rand', type => 'exponential', growth_factor => 2 }
10             });
11             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12             ] });
13              
14             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller', 'Paws::Net::JsonResponse';
15              
16            
17             sub AssociateNode {
18             my $self = shift;
19             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::AssociateNode', @_);
20             return $self->caller->do_call($self, $call_object);
21             }
22             sub CreateBackup {
23             my $self = shift;
24             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::CreateBackup', @_);
25             return $self->caller->do_call($self, $call_object);
26             }
27             sub CreateServer {
28             my $self = shift;
29             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::CreateServer', @_);
30             return $self->caller->do_call($self, $call_object);
31             }
32             sub DeleteBackup {
33             my $self = shift;
34             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::DeleteBackup', @_);
35             return $self->caller->do_call($self, $call_object);
36             }
37             sub DeleteServer {
38             my $self = shift;
39             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::DeleteServer', @_);
40             return $self->caller->do_call($self, $call_object);
41             }
42             sub DescribeAccountAttributes {
43             my $self = shift;
44             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::DescribeAccountAttributes', @_);
45             return $self->caller->do_call($self, $call_object);
46             }
47             sub DescribeBackups {
48             my $self = shift;
49             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::DescribeBackups', @_);
50             return $self->caller->do_call($self, $call_object);
51             }
52             sub DescribeEvents {
53             my $self = shift;
54             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::DescribeEvents', @_);
55             return $self->caller->do_call($self, $call_object);
56             }
57             sub DescribeNodeAssociationStatus {
58             my $self = shift;
59             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::DescribeNodeAssociationStatus', @_);
60             return $self->caller->do_call($self, $call_object);
61             }
62             sub DescribeServers {
63             my $self = shift;
64             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::DescribeServers', @_);
65             return $self->caller->do_call($self, $call_object);
66             }
67             sub DisassociateNode {
68             my $self = shift;
69             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::DisassociateNode', @_);
70             return $self->caller->do_call($self, $call_object);
71             }
72             sub RestoreServer {
73             my $self = shift;
74             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::RestoreServer', @_);
75             return $self->caller->do_call($self, $call_object);
76             }
77             sub StartMaintenance {
78             my $self = shift;
79             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::StartMaintenance', @_);
80             return $self->caller->do_call($self, $call_object);
81             }
82             sub UpdateServer {
83             my $self = shift;
84             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::UpdateServer', @_);
85             return $self->caller->do_call($self, $call_object);
86             }
87             sub UpdateServerEngineAttributes {
88             my $self = shift;
89             my $call_object = $self->new_with_coercions('Paws::OpsWorksCM::UpdateServerEngineAttributes', @_);
90             return $self->caller->do_call($self, $call_object);
91             }
92            
93              
94              
95             sub operations { qw/AssociateNode CreateBackup CreateServer DeleteBackup DeleteServer DescribeAccountAttributes DescribeBackups DescribeEvents DescribeNodeAssociationStatus DescribeServers DisassociateNode RestoreServer StartMaintenance UpdateServer UpdateServerEngineAttributes / }
96              
97             1;
98              
99             ### main pod documentation begin ###
100              
101             =head1 NAME
102              
103             Paws::OpsWorksCM - Perl Interface to AWS AWS OpsWorks for Chef Automate
104              
105             =head1 SYNOPSIS
106              
107             use Paws;
108              
109             my $obj = Paws->service('OpsWorksCM');
110             my $res = $obj->Method(
111             Arg1 => $val1,
112             Arg2 => [ 'V1', 'V2' ],
113             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
114             # of the arguments type
115             Arg3 => { Att1 => 'Val1' },
116             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
117             # the constructor of the arguments type
118             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
119             );
120              
121             =head1 DESCRIPTION
122              
123             AWS OpsWorks for Chef Automate
124              
125             AWS OpsWorks for Chef Automate is a service that runs and manages
126             configuration management servers.
127              
128             B<Glossary of terms>
129              
130             =over
131              
132             =item *
133              
134             B<Server>: A configuration management server that can be
135             highly-available. The configuration manager runs on your instances by
136             using various AWS services, such as Amazon Elastic Compute Cloud (EC2),
137             and potentially Amazon Relational Database Service (RDS). A server is a
138             generic abstraction over the configuration manager that you want to
139             use, much like Amazon RDS. In AWS OpsWorks for Chef Automate, you do
140             not start or stop servers. After you create servers, they continue to
141             run until they are deleted.
142              
143             =item *
144              
145             B<Engine>: The specific configuration manager that you want to use
146             (such as C<Chef>) is the engine.
147              
148             =item *
149              
150             B<Backup>: This is an application-level backup of the data that the
151             configuration manager stores. A backup creates a .tar.gz file that is
152             stored in an Amazon Simple Storage Service (S3) bucket in your account.
153             AWS OpsWorks for Chef Automate creates the S3 bucket when you launch
154             the first instance. A backup maintains a snapshot of all of a server's
155             important attributes at the time of the backup.
156              
157             =item *
158              
159             B<Events>: Events are always related to a server. Events are written
160             during server creation, when health checks run, when backups are
161             created, etc. When you delete a server, the server's events are also
162             deleted.
163              
164             =item *
165              
166             B<AccountAttributes>: Every account has attributes that are assigned in
167             the AWS OpsWorks for Chef Automate database. These attributes store
168             information about configuration limits (servers, backups, etc.) and
169             your customer account.
170              
171             =back
172              
173             B<Endpoints>
174              
175             AWS OpsWorks for Chef Automate supports the following endpoints, all
176             HTTPS. You must connect to one of the following endpoints. Chef servers
177             can only be accessed or managed within the endpoint in which they are
178             created.
179              
180             =over
181              
182             =item *
183              
184             opsworks-cm.us-east-1.amazonaws.com
185              
186             =item *
187              
188             opsworks-cm.us-west-2.amazonaws.com
189              
190             =item *
191              
192             opsworks-cm.eu-west-1.amazonaws.com
193              
194             =back
195              
196             B<Throttling limits>
197              
198             All API operations allow for five requests per second with a burst of
199             10 requests per second.
200              
201             =head1 METHODS
202              
203             =head2 AssociateNode(EngineAttributes => ArrayRef[L<Paws::OpsWorksCM::EngineAttribute>], NodeName => Str, ServerName => Str)
204              
205             Each argument is described in detail in: L<Paws::OpsWorksCM::AssociateNode>
206              
207             Returns: a L<Paws::OpsWorksCM::AssociateNodeResponse> instance
208              
209             Associates a new node with the Chef server. This command is an
210             alternative to C<knife bootstrap>. For more information about how to
211             disassociate a node, see DisassociateNode.
212              
213             A node can can only be associated with servers that are in a C<HEALTHY>
214             state. Otherwise, an C<InvalidStateException> is thrown. A
215             C<ResourceNotFoundException> is thrown when the server does not exist.
216             A C<ValidationException> is raised when parameters of the request are
217             not valid. The AssociateNode API call can be integrated into Auto
218             Scaling configurations, AWS Cloudformation templates, or the user data
219             of a server's instance.
220              
221             Example: C<aws opsworks-cm associate-node --server-name I<MyServer>
222             --node-name I<MyManagedNode> --engine-attributes
223             "Name=I<MyOrganization>,Value=default"
224             "Name=I<Chef_node_public_key>,Value=I<Public_key_contents>">
225              
226              
227             =head2 CreateBackup(ServerName => Str, [Description => Str])
228              
229             Each argument is described in detail in: L<Paws::OpsWorksCM::CreateBackup>
230              
231             Returns: a L<Paws::OpsWorksCM::CreateBackupResponse> instance
232              
233             Creates an application-level backup of a server. While the server is in
234             the C<BACKING_UP> state, the server cannot be changed, and no
235             additional backup can be created.
236              
237             Backups can be created for servers in C<RUNNING>, C<HEALTHY>, and
238             C<UNHEALTHY> states. By default, you can create a maximum of 50 manual
239             backups.
240              
241             This operation is asynchronous.
242              
243             A C<LimitExceededException> is thrown when the maximum number of manual
244             backups is reached. An C<InvalidStateException> is thrown when the
245             server is not in any of the following states: RUNNING, HEALTHY, or
246             UNHEALTHY. A C<ResourceNotFoundException> is thrown when the server is
247             not found. A C<ValidationException> is thrown when parameters of the
248             request are not valid.
249              
250              
251             =head2 CreateServer(InstanceProfileArn => Str, InstanceType => Str, ServerName => Str, ServiceRoleArn => Str, [AssociatePublicIpAddress => Bool, BackupId => Str, BackupRetentionCount => Int, DisableAutomatedBackup => Bool, Engine => Str, EngineAttributes => ArrayRef[L<Paws::OpsWorksCM::EngineAttribute>], EngineModel => Str, EngineVersion => Str, KeyPair => Str, PreferredBackupWindow => Str, PreferredMaintenanceWindow => Str, SecurityGroupIds => ArrayRef[Str|Undef], SubnetIds => ArrayRef[Str|Undef]])
252              
253             Each argument is described in detail in: L<Paws::OpsWorksCM::CreateServer>
254              
255             Returns: a L<Paws::OpsWorksCM::CreateServerResponse> instance
256              
257             Creates and immedately starts a new server. The server is ready to use
258             when it is in the C<HEALTHY> state. By default, you can create a
259             maximum of 10 servers.
260              
261             This operation is asynchronous.
262              
263             A C<LimitExceededException> is thrown when you have created the maximum
264             number of servers (10). A C<ResourceAlreadyExistsException> is thrown
265             when a server with the same name already exists in the account. A
266             C<ResourceNotFoundException> is thrown when you specify a backup ID
267             that is not valid or is for a backup that does not exist. A
268             C<ValidationException> is thrown when parameters of the request are not
269             valid.
270              
271             If you do not specify a security group by adding the
272             C<SecurityGroupIds> parameter, AWS OpsWorks creates a new security
273             group. The default security group opens the Chef server to the world on
274             TCP port 443. If a KeyName is present, AWS OpsWorks enables SSH access.
275             SSH is also open to the world on TCP port 22.
276              
277             By default, the Chef Server is accessible from any IP address. We
278             recommend that you update your security group rules to allow access
279             from known IP addresses and address ranges only. To edit security group
280             rules, open Security Groups in the navigation pane of the EC2
281             management console.
282              
283              
284             =head2 DeleteBackup(BackupId => Str)
285              
286             Each argument is described in detail in: L<Paws::OpsWorksCM::DeleteBackup>
287              
288             Returns: a L<Paws::OpsWorksCM::DeleteBackupResponse> instance
289              
290             Deletes a backup. You can delete both manual and automated backups.
291             This operation is asynchronous.
292              
293             An C<InvalidStateException> is thrown when a backup deletion is already
294             in progress. A C<ResourceNotFoundException> is thrown when the backup
295             does not exist. A C<ValidationException> is thrown when parameters of
296             the request are not valid.
297              
298              
299             =head2 DeleteServer(ServerName => Str)
300              
301             Each argument is described in detail in: L<Paws::OpsWorksCM::DeleteServer>
302              
303             Returns: a L<Paws::OpsWorksCM::DeleteServerResponse> instance
304              
305             Deletes the server and the underlying AWS CloudFormation stack
306             (including the server's EC2 instance). When you run this command, the
307             server state is updated to C<DELETING>. After the server is deleted, it
308             is no longer returned by C<DescribeServer> requests. If the AWS
309             CloudFormation stack cannot be deleted, the server cannot be deleted.
310              
311             This operation is asynchronous.
312              
313             An C<InvalidStateException> is thrown when a server deletion is already
314             in progress. A C<ResourceNotFoundException> is thrown when the server
315             does not exist. A C<ValidationException> is raised when parameters of
316             the request are not valid.
317              
318              
319             =head2 DescribeAccountAttributes()
320              
321             Each argument is described in detail in: L<Paws::OpsWorksCM::DescribeAccountAttributes>
322              
323             Returns: a L<Paws::OpsWorksCM::DescribeAccountAttributesResponse> instance
324              
325             Describes your account attributes, and creates requests to increase
326             limits before they are reached or exceeded.
327              
328             This operation is synchronous.
329              
330              
331             =head2 DescribeBackups([BackupId => Str, MaxResults => Int, NextToken => Str, ServerName => Str])
332              
333             Each argument is described in detail in: L<Paws::OpsWorksCM::DescribeBackups>
334              
335             Returns: a L<Paws::OpsWorksCM::DescribeBackupsResponse> instance
336              
337             Describes backups. The results are ordered by time, with newest backups
338             first. If you do not specify a BackupId or ServerName, the command
339             returns all backups.
340              
341             This operation is synchronous.
342              
343             A C<ResourceNotFoundException> is thrown when the backup does not
344             exist. A C<ValidationException> is raised when parameters of the
345             request are not valid.
346              
347              
348             =head2 DescribeEvents(ServerName => Str, [MaxResults => Int, NextToken => Str])
349              
350             Each argument is described in detail in: L<Paws::OpsWorksCM::DescribeEvents>
351              
352             Returns: a L<Paws::OpsWorksCM::DescribeEventsResponse> instance
353              
354             Describes events for a specified server. Results are ordered by time,
355             with newest events first.
356              
357             This operation is synchronous.
358              
359             A C<ResourceNotFoundException> is thrown when the server does not
360             exist. A C<ValidationException> is raised when parameters of the
361             request are not valid.
362              
363              
364             =head2 DescribeNodeAssociationStatus(NodeAssociationStatusToken => Str, ServerName => Str)
365              
366             Each argument is described in detail in: L<Paws::OpsWorksCM::DescribeNodeAssociationStatus>
367              
368             Returns: a L<Paws::OpsWorksCM::DescribeNodeAssociationStatusResponse> instance
369              
370             Returns the current status of an existing association or disassociation
371             request.
372              
373             A C<ResourceNotFoundException> is thrown when no recent association or
374             disassociation request with the specified token is found, or when the
375             server does not exist. A C<ValidationException> is raised when
376             parameters of the request are not valid.
377              
378              
379             =head2 DescribeServers([MaxResults => Int, NextToken => Str, ServerName => Str])
380              
381             Each argument is described in detail in: L<Paws::OpsWorksCM::DescribeServers>
382              
383             Returns: a L<Paws::OpsWorksCM::DescribeServersResponse> instance
384              
385             Lists all configuration management servers that are identified with
386             your account. Only the stored results from Amazon DynamoDB are
387             returned. AWS OpsWorks for Chef Automate does not query other services.
388              
389             This operation is synchronous.
390              
391             A C<ResourceNotFoundException> is thrown when the server does not
392             exist. A C<ValidationException> is raised when parameters of the
393             request are not valid.
394              
395              
396             =head2 DisassociateNode(NodeName => Str, ServerName => Str, [EngineAttributes => ArrayRef[L<Paws::OpsWorksCM::EngineAttribute>]])
397              
398             Each argument is described in detail in: L<Paws::OpsWorksCM::DisassociateNode>
399              
400             Returns: a L<Paws::OpsWorksCM::DisassociateNodeResponse> instance
401              
402             Disassociates a node from a Chef server, and removes the node from the
403             Chef server's managed nodes. After a node is disassociated, the node
404             key pair is no longer valid for accessing the Chef API. For more
405             information about how to associate a node, see AssociateNode.
406              
407             A node can can only be disassociated from a server that is in a
408             C<HEALTHY> state. Otherwise, an C<InvalidStateException> is thrown. A
409             C<ResourceNotFoundException> is thrown when the server does not exist.
410             A C<ValidationException> is raised when parameters of the request are
411             not valid.
412              
413              
414             =head2 RestoreServer(BackupId => Str, ServerName => Str, [InstanceType => Str, KeyPair => Str])
415              
416             Each argument is described in detail in: L<Paws::OpsWorksCM::RestoreServer>
417              
418             Returns: a L<Paws::OpsWorksCM::RestoreServerResponse> instance
419              
420             Restores a backup to a server that is in a C<CONNECTION_LOST>,
421             C<HEALTHY>, C<RUNNING>, C<UNHEALTHY>, or C<TERMINATED> state. When you
422             run RestoreServer, the server's EC2 instance is deleted, and a new EC2
423             instance is configured. RestoreServer maintains the existing server
424             endpoint, so configuration management of the server's client devices
425             (nodes) should continue to work.
426              
427             This operation is asynchronous.
428              
429             An C<InvalidStateException> is thrown when the server is not in a valid
430             state. A C<ResourceNotFoundException> is thrown when the server does
431             not exist. A C<ValidationException> is raised when parameters of the
432             request are not valid.
433              
434              
435             =head2 StartMaintenance(ServerName => Str)
436              
437             Each argument is described in detail in: L<Paws::OpsWorksCM::StartMaintenance>
438              
439             Returns: a L<Paws::OpsWorksCM::StartMaintenanceResponse> instance
440              
441             Manually starts server maintenance. This command can be useful if an
442             earlier maintenance attempt failed, and the underlying cause of
443             maintenance failure has been resolved. The server is in an
444             C<UNDER_MAINTENANCE> state while maintenance is in progress.
445              
446             Maintenance can only be started on servers in C<HEALTHY> and
447             C<UNHEALTHY> states. Otherwise, an C<InvalidStateException> is thrown.
448             A C<ResourceNotFoundException> is thrown when the server does not
449             exist. A C<ValidationException> is raised when parameters of the
450             request are not valid.
451              
452              
453             =head2 UpdateServer(ServerName => Str, [BackupRetentionCount => Int, DisableAutomatedBackup => Bool, PreferredBackupWindow => Str, PreferredMaintenanceWindow => Str])
454              
455             Each argument is described in detail in: L<Paws::OpsWorksCM::UpdateServer>
456              
457             Returns: a L<Paws::OpsWorksCM::UpdateServerResponse> instance
458              
459             Updates settings for a server.
460              
461             This operation is synchronous.
462              
463              
464             =head2 UpdateServerEngineAttributes(AttributeName => Str, ServerName => Str, [AttributeValue => Str])
465              
466             Each argument is described in detail in: L<Paws::OpsWorksCM::UpdateServerEngineAttributes>
467              
468             Returns: a L<Paws::OpsWorksCM::UpdateServerEngineAttributesResponse> instance
469              
470             Updates engine-specific attributes on a specified server. The server
471             enters the C<MODIFYING> state when this operation is in progress. Only
472             one update can occur at a time. You can use this command to reset the
473             Chef server's private key (C<CHEF_PIVOTAL_KEY>).
474              
475             This operation is asynchronous.
476              
477             This operation can only be called for servers in C<HEALTHY> or
478             C<UNHEALTHY> states. Otherwise, an C<InvalidStateException> is raised.
479             A C<ResourceNotFoundException> is thrown when the server does not
480             exist. A C<ValidationException> is raised when parameters of the
481             request are not valid.
482              
483              
484              
485              
486             =head1 PAGINATORS
487              
488             Paginator methods are helpers that repetively call methods that return partial results
489              
490              
491              
492              
493             =head1 SEE ALSO
494              
495             This service class forms part of L<Paws>
496              
497             =head1 BUGS and CONTRIBUTIONS
498              
499             The source code is located here: https://github.com/pplu/aws-sdk-perl
500              
501             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
502              
503             =cut
504