blib/lib/Paws/EBS.pm untested

filter: Statementstmt 0.0% 0 / 31 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 12 Podpod 0.0% 0 / 11 totaltotal 0.0% 0 / 54 CC 1 SCAR 6.9
CC
1
Cov
0%
service
2.0
signing_name
2.0
version
2.0
CRAP 2.0
1 package Paws::EBS;
2 use Moose;
3 sub service { 'ebs' }
4 sub signing_name { 'ebs' }
5 sub version { '2019-11-02' }
6 sub flattened_arrays { 0 }
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::RestJsonCaller';
15  
16
17 sub CompleteSnapshot {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::EBS::CompleteSnapshot', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub GetSnapshotBlock {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::EBS::GetSnapshotBlock', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub ListChangedBlocks {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::EBS::ListChangedBlocks', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub ListSnapshotBlocks {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::EBS::ListSnapshotBlocks', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub PutSnapshotBlock {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::EBS::PutSnapshotBlock', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub StartSnapshot {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::EBS::StartSnapshot', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47
48  
49  
50 sub operations { qw/CompleteSnapshot GetSnapshotBlock ListChangedBlocks ListSnapshotBlocks PutSnapshotBlock StartSnapshot / }
51  
52 1;
53  
54 ### main pod documentation begin ###
55  
56 =head1 NAME
57  
58 Paws::EBS - Perl Interface to AWS Amazon Elastic Block Store
59  
60 =head1 SYNOPSIS
61  
62 use Paws;
63  
64 my $obj = Paws->service('EBS');
65 my $res = $obj->Method(
66 Arg1 => $val1,
67 Arg2 => [ 'V1', 'V2' ],
68 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
69 # of the arguments type
70 Arg3 => { Att1 => 'Val1' },
71 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
72 # the constructor of the arguments type
73 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
74 );
75  
76 =head1 DESCRIPTION
77  
78 You can use the Amazon Elastic Block Store (Amazon EBS) direct APIs to
79 create EBS snapshots, write data directly to your snapshots, read data
80 on your snapshots, and identify the differences or changes between two
81 snapshots. If youE<rsquo>re an independent software vendor (ISV) who
82 offers backup services for Amazon EBS, the EBS direct APIs make it more
83 efficient and cost-effective to track incremental changes on your EBS
84 volumes through snapshots. This can be done without having to create
85 new volumes from snapshots, and then use Amazon Elastic Compute Cloud
86 (Amazon EC2) instances to compare the differences.
87  
88 You can create incremental snapshots directly from data on-premises
89 into EBS volumes and the cloud to use for quick disaster recovery. With
90 the ability to write and read snapshots, you can write your on-premises
91 data to an EBS snapshot during a disaster. Then after recovery, you can
92 restore it back to AWS or on-premises from the snapshot. You no longer
93 need to build and maintain complex mechanisms to copy data to and from
94 Amazon EBS.
95  
96 This API reference provides detailed information about the actions,
97 data types, parameters, and errors of the EBS direct APIs. For more
98 information about the elements that make up the EBS direct APIs, and
99 examples of how to use them effectively, see Accessing the Contents of
100 an EBS Snapshot
101 (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html)
102 in the I<Amazon Elastic Compute Cloud User Guide>. For more information
103 about the supported AWS Regions, endpoints, and service quotas for the
104 EBS direct APIs, see Amazon Elastic Block Store Endpoints and Quotas
105 (https://docs.aws.amazon.com/general/latest/gr/ebs-service.html) in the
106 I<AWS General Reference>.
107  
108 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/ebs-2019-11-02>
109  
110  
111 =head1 METHODS
112  
113 =head2 CompleteSnapshot
114  
115 =over
116  
117 =item ChangedBlocksCount => Int
118  
119 =item SnapshotId => Str
120  
121 =item [Checksum => Str]
122  
123 =item [ChecksumAggregationMethod => Str]
124  
125 =item [ChecksumAlgorithm => Str]
126  
127  
128 =back
129  
130 Each argument is described in detail in: L<Paws::EBS::CompleteSnapshot>
131  
132 Returns: a L<Paws::EBS::CompleteSnapshotResponse> instance
133  
134 Seals and completes the snapshot after all of the required blocks of
135 data have been written to it. Completing the snapshot changes the
136 status to C<completed>. You cannot write new blocks to a snapshot after
137 it has been completed.
138  
139  
140 =head2 GetSnapshotBlock
141  
142 =over
143  
144 =item BlockIndex => Int
145  
146 =item BlockToken => Str
147  
148 =item SnapshotId => Str
149  
150  
151 =back
152  
153 Each argument is described in detail in: L<Paws::EBS::GetSnapshotBlock>
154  
155 Returns: a L<Paws::EBS::GetSnapshotBlockResponse> instance
156  
157 Returns the data in a block in an Amazon Elastic Block Store snapshot.
158  
159  
160 =head2 ListChangedBlocks
161  
162 =over
163  
164 =item SecondSnapshotId => Str
165  
166 =item [FirstSnapshotId => Str]
167  
168 =item [MaxResults => Int]
169  
170 =item [NextToken => Str]
171  
172 =item [StartingBlockIndex => Int]
173  
174  
175 =back
176  
177 Each argument is described in detail in: L<Paws::EBS::ListChangedBlocks>
178  
179 Returns: a L<Paws::EBS::ListChangedBlocksResponse> instance
180  
181 Returns information about the blocks that are different between two
182 Amazon Elastic Block Store snapshots of the same volume/snapshot
183 lineage.
184  
185  
186 =head2 ListSnapshotBlocks
187  
188 =over
189  
190 =item SnapshotId => Str
191  
192 =item [MaxResults => Int]
193  
194 =item [NextToken => Str]
195  
196 =item [StartingBlockIndex => Int]
197  
198  
199 =back
200  
201 Each argument is described in detail in: L<Paws::EBS::ListSnapshotBlocks>
202  
203 Returns: a L<Paws::EBS::ListSnapshotBlocksResponse> instance
204  
205 Returns information about the blocks in an Amazon Elastic Block Store
206 snapshot.
207  
208  
209 =head2 PutSnapshotBlock
210  
211 =over
212  
213 =item BlockData => Str
214  
215 =item BlockIndex => Int
216  
217 =item Checksum => Str
218  
219 =item ChecksumAlgorithm => Str
220  
221 =item DataLength => Int
222  
223 =item SnapshotId => Str
224  
225 =item [Progress => Int]
226  
227  
228 =back
229  
230 Each argument is described in detail in: L<Paws::EBS::PutSnapshotBlock>
231  
232 Returns: a L<Paws::EBS::PutSnapshotBlockResponse> instance
233  
234 Writes a block of data to a snapshot. If the specified block contains
235 data, the existing data is overwritten. The target snapshot must be in
236 the C<pending> state.
237  
238 Data written to a snapshot must be aligned with 512-byte sectors.
239  
240  
241 =head2 StartSnapshot
242  
243 =over
244  
245 =item VolumeSize => Int
246  
247 =item [ClientToken => Str]
248  
249 =item [Description => Str]
250  
251 =item [Encrypted => Bool]
252  
253 =item [KmsKeyArn => Str]
254  
255 =item [ParentSnapshotId => Str]
256  
257 =item [Tags => ArrayRef[L<Paws::EBS::Tag>]]
258  
259 =item [Timeout => Int]
260  
261  
262 =back
263  
264 Each argument is described in detail in: L<Paws::EBS::StartSnapshot>
265  
266 Returns: a L<Paws::EBS::StartSnapshotResponse> instance
267  
268 Creates a new Amazon EBS snapshot. The new snapshot enters the
269 C<pending> state after the request completes.
270  
271 After creating the snapshot, use PutSnapshotBlock
272 (https://docs.aws.amazon.com/ebs/latest/APIReference/API_PutSnapshotBlock.html)
273 to write blocks of data to the snapshot.
274  
275  
276  
277  
278 =head1 PAGINATORS
279  
280 Paginator methods are helpers that repetively call methods that return partial results
281  
282  
283  
284  
285 =head1 SEE ALSO
286  
287 This service class forms part of L<Paws>
288  
289 =head1 BUGS and CONTRIBUTIONS
290  
291 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
292  
293 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
294  
295 =cut
296