File Coverage

blib/lib/Paws/ElastiCache.pm
Criterion Covered Total %
statement 7 343 2.0
branch 0 48 0.0
condition n/a
subroutine 3 57 5.2
pod 51 55 92.7
total 61 503 12.1


line stmt bran cond sub pod time code
1             package Paws::ElastiCache;
2 1     1   4503 use Moose;
  1     1   3  
  1         13  
  1         2609  
  1         2  
  1         8  
3 9     9 0 36 sub service { 'elasticache' }
4 0     0 0   sub version { '2015-02-02' }
5 0     0 0   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::QueryCaller', 'Paws::Net::XMLResponse';
14              
15            
16             sub AddTagsToResource {
17 0     0 1   my $self = shift;
18 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::AddTagsToResource', @_);
19 0           return $self->caller->do_call($self, $call_object);
20             }
21             sub AuthorizeCacheSecurityGroupIngress {
22 0     0 1   my $self = shift;
23 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::AuthorizeCacheSecurityGroupIngress', @_);
24 0           return $self->caller->do_call($self, $call_object);
25             }
26             sub CopySnapshot {
27 0     0 1   my $self = shift;
28 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::CopySnapshot', @_);
29 0           return $self->caller->do_call($self, $call_object);
30             }
31             sub CreateCacheCluster {
32 0     0 1   my $self = shift;
33 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateCacheCluster', @_);
34 0           return $self->caller->do_call($self, $call_object);
35             }
36             sub CreateCacheParameterGroup {
37 0     0 1   my $self = shift;
38 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateCacheParameterGroup', @_);
39 0           return $self->caller->do_call($self, $call_object);
40             }
41             sub CreateCacheSecurityGroup {
42 0     0 1   my $self = shift;
43 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateCacheSecurityGroup', @_);
44 0           return $self->caller->do_call($self, $call_object);
45             }
46             sub CreateCacheSubnetGroup {
47 0     0 1   my $self = shift;
48 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateCacheSubnetGroup', @_);
49 0           return $self->caller->do_call($self, $call_object);
50             }
51             sub CreateReplicationGroup {
52 0     0 1   my $self = shift;
53 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateReplicationGroup', @_);
54 0           return $self->caller->do_call($self, $call_object);
55             }
56             sub CreateSnapshot {
57 0     0 1   my $self = shift;
58 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateSnapshot', @_);
59 0           return $self->caller->do_call($self, $call_object);
60             }
61             sub DeleteCacheCluster {
62 0     0 1   my $self = shift;
63 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteCacheCluster', @_);
64 0           return $self->caller->do_call($self, $call_object);
65             }
66             sub DeleteCacheParameterGroup {
67 0     0 1   my $self = shift;
68 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteCacheParameterGroup', @_);
69 0           return $self->caller->do_call($self, $call_object);
70             }
71             sub DeleteCacheSecurityGroup {
72 0     0 1   my $self = shift;
73 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteCacheSecurityGroup', @_);
74 0           return $self->caller->do_call($self, $call_object);
75             }
76             sub DeleteCacheSubnetGroup {
77 0     0 1   my $self = shift;
78 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteCacheSubnetGroup', @_);
79 0           return $self->caller->do_call($self, $call_object);
80             }
81             sub DeleteReplicationGroup {
82 0     0 1   my $self = shift;
83 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteReplicationGroup', @_);
84 0           return $self->caller->do_call($self, $call_object);
85             }
86             sub DeleteSnapshot {
87 0     0 1   my $self = shift;
88 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteSnapshot', @_);
89 0           return $self->caller->do_call($self, $call_object);
90             }
91             sub DescribeCacheClusters {
92 0     0 1   my $self = shift;
93 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheClusters', @_);
94 0           return $self->caller->do_call($self, $call_object);
95             }
96             sub DescribeCacheEngineVersions {
97 0     0 1   my $self = shift;
98 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheEngineVersions', @_);
99 0           return $self->caller->do_call($self, $call_object);
100             }
101             sub DescribeCacheParameterGroups {
102 0     0 1   my $self = shift;
103 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheParameterGroups', @_);
104 0           return $self->caller->do_call($self, $call_object);
105             }
106             sub DescribeCacheParameters {
107 0     0 1   my $self = shift;
108 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheParameters', @_);
109 0           return $self->caller->do_call($self, $call_object);
110             }
111             sub DescribeCacheSecurityGroups {
112 0     0 1   my $self = shift;
113 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheSecurityGroups', @_);
114 0           return $self->caller->do_call($self, $call_object);
115             }
116             sub DescribeCacheSubnetGroups {
117 0     0 1   my $self = shift;
118 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheSubnetGroups', @_);
119 0           return $self->caller->do_call($self, $call_object);
120             }
121             sub DescribeEngineDefaultParameters {
122 0     0 1   my $self = shift;
123 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeEngineDefaultParameters', @_);
124 0           return $self->caller->do_call($self, $call_object);
125             }
126             sub DescribeEvents {
127 0     0 1   my $self = shift;
128 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeEvents', @_);
129 0           return $self->caller->do_call($self, $call_object);
130             }
131             sub DescribeReplicationGroups {
132 0     0 1   my $self = shift;
133 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeReplicationGroups', @_);
134 0           return $self->caller->do_call($self, $call_object);
135             }
136             sub DescribeReservedCacheNodes {
137 0     0 1   my $self = shift;
138 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeReservedCacheNodes', @_);
139 0           return $self->caller->do_call($self, $call_object);
140             }
141             sub DescribeReservedCacheNodesOfferings {
142 0     0 1   my $self = shift;
143 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeReservedCacheNodesOfferings', @_);
144 0           return $self->caller->do_call($self, $call_object);
145             }
146             sub DescribeSnapshots {
147 0     0 1   my $self = shift;
148 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeSnapshots', @_);
149 0           return $self->caller->do_call($self, $call_object);
150             }
151             sub ListAllowedNodeTypeModifications {
152 0     0 1   my $self = shift;
153 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::ListAllowedNodeTypeModifications', @_);
154 0           return $self->caller->do_call($self, $call_object);
155             }
156             sub ListTagsForResource {
157 0     0 1   my $self = shift;
158 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::ListTagsForResource', @_);
159 0           return $self->caller->do_call($self, $call_object);
160             }
161             sub ModifyCacheCluster {
162 0     0 1   my $self = shift;
163 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyCacheCluster', @_);
164 0           return $self->caller->do_call($self, $call_object);
165             }
166             sub ModifyCacheParameterGroup {
167 0     0 1   my $self = shift;
168 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyCacheParameterGroup', @_);
169 0           return $self->caller->do_call($self, $call_object);
170             }
171             sub ModifyCacheSubnetGroup {
172 0     0 1   my $self = shift;
173 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyCacheSubnetGroup', @_);
174 0           return $self->caller->do_call($self, $call_object);
175             }
176             sub ModifyReplicationGroup {
177 0     0 1   my $self = shift;
178 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyReplicationGroup', @_);
179 0           return $self->caller->do_call($self, $call_object);
180             }
181             sub PurchaseReservedCacheNodesOffering {
182 0     0 1   my $self = shift;
183 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::PurchaseReservedCacheNodesOffering', @_);
184 0           return $self->caller->do_call($self, $call_object);
185             }
186             sub RebootCacheCluster {
187 0     0 1   my $self = shift;
188 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::RebootCacheCluster', @_);
189 0           return $self->caller->do_call($self, $call_object);
190             }
191             sub RemoveTagsFromResource {
192 0     0 1   my $self = shift;
193 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::RemoveTagsFromResource', @_);
194 0           return $self->caller->do_call($self, $call_object);
195             }
196             sub ResetCacheParameterGroup {
197 0     0 1   my $self = shift;
198 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::ResetCacheParameterGroup', @_);
199 0           return $self->caller->do_call($self, $call_object);
200             }
201             sub RevokeCacheSecurityGroupIngress {
202 0     0 1   my $self = shift;
203 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::RevokeCacheSecurityGroupIngress', @_);
204 0           return $self->caller->do_call($self, $call_object);
205             }
206             sub TestFailover {
207 0     0 1   my $self = shift;
208 0           my $call_object = $self->new_with_coercions('Paws::ElastiCache::TestFailover', @_);
209 0           return $self->caller->do_call($self, $call_object);
210             }
211            
212             sub DescribeAllCacheClusters {
213 0     0 1   my $self = shift;
214              
215 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
216 0           my $result = $self->DescribeCacheClusters(@_);
217 0           my $next_result = $result;
218              
219 0 0         if (not defined $callback) {
220 0           while ($next_result->Marker) {
221 0           $next_result = $self->DescribeCacheClusters(@_, Marker => $next_result->Marker);
222 0           push @{ $result->CacheClusters }, @{ $next_result->CacheClusters };
  0            
  0            
223             }
224 0           return $result;
225             } else {
226 0           while ($result->Marker) {
227 0           $callback->($_ => 'CacheClusters') foreach (@{ $result->CacheClusters });
  0            
228 0           $result = $self->DescribeCacheClusters(@_, Marker => $result->Marker);
229             }
230 0           $callback->($_ => 'CacheClusters') foreach (@{ $result->CacheClusters });
  0            
231             }
232              
233             return undef
234 0           }
235             sub DescribeAllCacheEngineVersions {
236 0     0 1   my $self = shift;
237              
238 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
239 0           my $result = $self->DescribeCacheEngineVersions(@_);
240 0           my $next_result = $result;
241              
242 0 0         if (not defined $callback) {
243 0           while ($next_result->Marker) {
244 0           $next_result = $self->DescribeCacheEngineVersions(@_, Marker => $next_result->Marker);
245 0           push @{ $result->CacheEngineVersions }, @{ $next_result->CacheEngineVersions };
  0            
  0            
246             }
247 0           return $result;
248             } else {
249 0           while ($result->Marker) {
250 0           $callback->($_ => 'CacheEngineVersions') foreach (@{ $result->CacheEngineVersions });
  0            
251 0           $result = $self->DescribeCacheEngineVersions(@_, Marker => $result->Marker);
252             }
253 0           $callback->($_ => 'CacheEngineVersions') foreach (@{ $result->CacheEngineVersions });
  0            
254             }
255              
256             return undef
257 0           }
258             sub DescribeAllCacheParameterGroups {
259 0     0 1   my $self = shift;
260              
261 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
262 0           my $result = $self->DescribeCacheParameterGroups(@_);
263 0           my $next_result = $result;
264              
265 0 0         if (not defined $callback) {
266 0           while ($next_result->Marker) {
267 0           $next_result = $self->DescribeCacheParameterGroups(@_, Marker => $next_result->Marker);
268 0           push @{ $result->CacheParameterGroups }, @{ $next_result->CacheParameterGroups };
  0            
  0            
269             }
270 0           return $result;
271             } else {
272 0           while ($result->Marker) {
273 0           $callback->($_ => 'CacheParameterGroups') foreach (@{ $result->CacheParameterGroups });
  0            
274 0           $result = $self->DescribeCacheParameterGroups(@_, Marker => $result->Marker);
275             }
276 0           $callback->($_ => 'CacheParameterGroups') foreach (@{ $result->CacheParameterGroups });
  0            
277             }
278              
279             return undef
280 0           }
281             sub DescribeAllCacheParameters {
282 0     0 1   my $self = shift;
283              
284 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
285 0           my $result = $self->DescribeCacheParameters(@_);
286 0           my $next_result = $result;
287              
288 0 0         if (not defined $callback) {
289 0           while ($next_result->Marker) {
290 0           $next_result = $self->DescribeCacheParameters(@_, Marker => $next_result->Marker);
291 0           push @{ $result->Parameters }, @{ $next_result->Parameters };
  0            
  0            
292             }
293 0           return $result;
294             } else {
295 0           while ($result->Marker) {
296 0           $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
  0            
297 0           $result = $self->DescribeCacheParameters(@_, Marker => $result->Marker);
298             }
299 0           $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
  0            
300             }
301              
302             return undef
303 0           }
304             sub DescribeAllCacheSecurityGroups {
305 0     0 1   my $self = shift;
306              
307 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
308 0           my $result = $self->DescribeCacheSecurityGroups(@_);
309 0           my $next_result = $result;
310              
311 0 0         if (not defined $callback) {
312 0           while ($next_result->Marker) {
313 0           $next_result = $self->DescribeCacheSecurityGroups(@_, Marker => $next_result->Marker);
314 0           push @{ $result->CacheSecurityGroups }, @{ $next_result->CacheSecurityGroups };
  0            
  0            
315             }
316 0           return $result;
317             } else {
318 0           while ($result->Marker) {
319 0           $callback->($_ => 'CacheSecurityGroups') foreach (@{ $result->CacheSecurityGroups });
  0            
320 0           $result = $self->DescribeCacheSecurityGroups(@_, Marker => $result->Marker);
321             }
322 0           $callback->($_ => 'CacheSecurityGroups') foreach (@{ $result->CacheSecurityGroups });
  0            
323             }
324              
325             return undef
326 0           }
327             sub DescribeAllCacheSubnetGroups {
328 0     0 1   my $self = shift;
329              
330 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
331 0           my $result = $self->DescribeCacheSubnetGroups(@_);
332 0           my $next_result = $result;
333              
334 0 0         if (not defined $callback) {
335 0           while ($next_result->Marker) {
336 0           $next_result = $self->DescribeCacheSubnetGroups(@_, Marker => $next_result->Marker);
337 0           push @{ $result->CacheSubnetGroups }, @{ $next_result->CacheSubnetGroups };
  0            
  0            
338             }
339 0           return $result;
340             } else {
341 0           while ($result->Marker) {
342 0           $callback->($_ => 'CacheSubnetGroups') foreach (@{ $result->CacheSubnetGroups });
  0            
343 0           $result = $self->DescribeCacheSubnetGroups(@_, Marker => $result->Marker);
344             }
345 0           $callback->($_ => 'CacheSubnetGroups') foreach (@{ $result->CacheSubnetGroups });
  0            
346             }
347              
348             return undef
349 0           }
350             sub DescribeAllEngineDefaultParameters {
351 0     0 1   my $self = shift;
352              
353 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
354 0           my $result = $self->DescribeEngineDefaultParameters(@_);
355 0           my $next_result = $result;
356              
357 0 0         if (not defined $callback) {
358 0           while ($next_result->EngineDefaults->Marker) {
359 0           $next_result = $self->DescribeEngineDefaultParameters(@_, Marker => $next_result->EngineDefaults->Marker);
360 0           push @{ $result->EngineDefaults->Parameters }, @{ $next_result->EngineDefaults->Parameters };
  0            
  0            
361             }
362 0           return $result;
363             } else {
364 0           while ($result->EngineDefaults->Marker) {
365 0           $callback->($_ => 'EngineDefaults.Parameters') foreach (@{ $result->EngineDefaults->Parameters });
  0            
366 0           $result = $self->DescribeEngineDefaultParameters(@_, Marker => $result->EngineDefaults->Marker);
367             }
368 0           $callback->($_ => 'EngineDefaults.Parameters') foreach (@{ $result->EngineDefaults->Parameters });
  0            
369             }
370              
371             return undef
372 0           }
373             sub DescribeAllEvents {
374 0     0 1   my $self = shift;
375              
376 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
377 0           my $result = $self->DescribeEvents(@_);
378 0           my $next_result = $result;
379              
380 0 0         if (not defined $callback) {
381 0           while ($next_result->Marker) {
382 0           $next_result = $self->DescribeEvents(@_, Marker => $next_result->Marker);
383 0           push @{ $result->Events }, @{ $next_result->Events };
  0            
  0            
384             }
385 0           return $result;
386             } else {
387 0           while ($result->Marker) {
388 0           $callback->($_ => 'Events') foreach (@{ $result->Events });
  0            
389 0           $result = $self->DescribeEvents(@_, Marker => $result->Marker);
390             }
391 0           $callback->($_ => 'Events') foreach (@{ $result->Events });
  0            
392             }
393              
394             return undef
395 0           }
396             sub DescribeAllReplicationGroups {
397 0     0 1   my $self = shift;
398              
399 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
400 0           my $result = $self->DescribeReplicationGroups(@_);
401 0           my $next_result = $result;
402              
403 0 0         if (not defined $callback) {
404 0           while ($next_result->Marker) {
405 0           $next_result = $self->DescribeReplicationGroups(@_, Marker => $next_result->Marker);
406 0           push @{ $result->ReplicationGroups }, @{ $next_result->ReplicationGroups };
  0            
  0            
407             }
408 0           return $result;
409             } else {
410 0           while ($result->Marker) {
411 0           $callback->($_ => 'ReplicationGroups') foreach (@{ $result->ReplicationGroups });
  0            
412 0           $result = $self->DescribeReplicationGroups(@_, Marker => $result->Marker);
413             }
414 0           $callback->($_ => 'ReplicationGroups') foreach (@{ $result->ReplicationGroups });
  0            
415             }
416              
417             return undef
418 0           }
419             sub DescribeAllReservedCacheNodes {
420 0     0 1   my $self = shift;
421              
422 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
423 0           my $result = $self->DescribeReservedCacheNodes(@_);
424 0           my $next_result = $result;
425              
426 0 0         if (not defined $callback) {
427 0           while ($next_result->Marker) {
428 0           $next_result = $self->DescribeReservedCacheNodes(@_, Marker => $next_result->Marker);
429 0           push @{ $result->ReservedCacheNodes }, @{ $next_result->ReservedCacheNodes };
  0            
  0            
430             }
431 0           return $result;
432             } else {
433 0           while ($result->Marker) {
434 0           $callback->($_ => 'ReservedCacheNodes') foreach (@{ $result->ReservedCacheNodes });
  0            
435 0           $result = $self->DescribeReservedCacheNodes(@_, Marker => $result->Marker);
436             }
437 0           $callback->($_ => 'ReservedCacheNodes') foreach (@{ $result->ReservedCacheNodes });
  0            
438             }
439              
440             return undef
441 0           }
442             sub DescribeAllReservedCacheNodesOfferings {
443 0     0 1   my $self = shift;
444              
445 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
446 0           my $result = $self->DescribeReservedCacheNodesOfferings(@_);
447 0           my $next_result = $result;
448              
449 0 0         if (not defined $callback) {
450 0           while ($next_result->Marker) {
451 0           $next_result = $self->DescribeReservedCacheNodesOfferings(@_, Marker => $next_result->Marker);
452 0           push @{ $result->ReservedCacheNodesOfferings }, @{ $next_result->ReservedCacheNodesOfferings };
  0            
  0            
453             }
454 0           return $result;
455             } else {
456 0           while ($result->Marker) {
457 0           $callback->($_ => 'ReservedCacheNodesOfferings') foreach (@{ $result->ReservedCacheNodesOfferings });
  0            
458 0           $result = $self->DescribeReservedCacheNodesOfferings(@_, Marker => $result->Marker);
459             }
460 0           $callback->($_ => 'ReservedCacheNodesOfferings') foreach (@{ $result->ReservedCacheNodesOfferings });
  0            
461             }
462              
463             return undef
464 0           }
465             sub DescribeAllSnapshots {
466 0     0 1   my $self = shift;
467              
468 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
469 0           my $result = $self->DescribeSnapshots(@_);
470 0           my $next_result = $result;
471              
472 0 0         if (not defined $callback) {
473 0           while ($next_result->Marker) {
474 0           $next_result = $self->DescribeSnapshots(@_, Marker => $next_result->Marker);
475 0           push @{ $result->Snapshots }, @{ $next_result->Snapshots };
  0            
  0            
476             }
477 0           return $result;
478             } else {
479 0           while ($result->Marker) {
480 0           $callback->($_ => 'Snapshots') foreach (@{ $result->Snapshots });
  0            
481 0           $result = $self->DescribeSnapshots(@_, Marker => $result->Marker);
482             }
483 0           $callback->($_ => 'Snapshots') foreach (@{ $result->Snapshots });
  0            
484             }
485              
486             return undef
487 0           }
488              
489              
490 0     0 0   sub operations { qw/AddTagsToResource AuthorizeCacheSecurityGroupIngress CopySnapshot CreateCacheCluster CreateCacheParameterGroup CreateCacheSecurityGroup CreateCacheSubnetGroup CreateReplicationGroup CreateSnapshot DeleteCacheCluster DeleteCacheParameterGroup DeleteCacheSecurityGroup DeleteCacheSubnetGroup DeleteReplicationGroup DeleteSnapshot DescribeCacheClusters DescribeCacheEngineVersions DescribeCacheParameterGroups DescribeCacheParameters DescribeCacheSecurityGroups DescribeCacheSubnetGroups DescribeEngineDefaultParameters DescribeEvents DescribeReplicationGroups DescribeReservedCacheNodes DescribeReservedCacheNodesOfferings DescribeSnapshots ListAllowedNodeTypeModifications ListTagsForResource ModifyCacheCluster ModifyCacheParameterGroup ModifyCacheSubnetGroup ModifyReplicationGroup PurchaseReservedCacheNodesOffering RebootCacheCluster RemoveTagsFromResource ResetCacheParameterGroup RevokeCacheSecurityGroupIngress TestFailover / }
491              
492             1;
493              
494             ### main pod documentation begin ###
495              
496             =head1 NAME
497              
498             Paws::ElastiCache - Perl Interface to AWS Amazon ElastiCache
499              
500             =head1 SYNOPSIS
501              
502             use Paws;
503              
504             my $obj = Paws->service('ElastiCache');
505             my $res = $obj->Method(
506             Arg1 => $val1,
507             Arg2 => [ 'V1', 'V2' ],
508             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
509             # of the arguments type
510             Arg3 => { Att1 => 'Val1' },
511             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
512             # the constructor of the arguments type
513             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
514             );
515              
516             =head1 DESCRIPTION
517              
518             Amazon ElastiCache
519              
520             Amazon ElastiCache is a web service that makes it easier to set up,
521             operate, and scale a distributed cache in the cloud.
522              
523             With ElastiCache, customers get all of the benefits of a
524             high-performance, in-memory cache with less of the administrative
525             burden involved in launching and managing a distributed cache. The
526             service makes setup, scaling, and cluster failure handling much simpler
527             than in a self-managed cache deployment.
528              
529             In addition, through integration with Amazon CloudWatch, customers get
530             enhanced visibility into the key performance statistics associated with
531             their cache and can receive alarms if a part of their cache runs hot.
532              
533             =head1 METHODS
534              
535             =head2 AddTagsToResource(ResourceName => Str, Tags => ArrayRef[L<Paws::ElastiCache::Tag>])
536              
537             Each argument is described in detail in: L<Paws::ElastiCache::AddTagsToResource>
538              
539             Returns: a L<Paws::ElastiCache::TagListMessage> instance
540              
541             Adds up to 50 cost allocation tags to the named resource. A cost
542             allocation tag is a key-value pair where the key and value are
543             case-sensitive. You can use cost allocation tags to categorize and
544             track your AWS costs.
545              
546             When you apply tags to your ElastiCache resources, AWS generates a cost
547             allocation report as a comma-separated value (CSV) file with your usage
548             and costs aggregated by your tags. You can apply tags that represent
549             business categories (such as cost centers, application names, or
550             owners) to organize your costs across multiple services. For more
551             information, see Using Cost Allocation Tags in Amazon ElastiCache in
552             the I<ElastiCache User Guide>.
553              
554              
555             =head2 AuthorizeCacheSecurityGroupIngress(CacheSecurityGroupName => Str, EC2SecurityGroupName => Str, EC2SecurityGroupOwnerId => Str)
556              
557             Each argument is described in detail in: L<Paws::ElastiCache::AuthorizeCacheSecurityGroupIngress>
558              
559             Returns: a L<Paws::ElastiCache::AuthorizeCacheSecurityGroupIngressResult> instance
560              
561             Allows network ingress to a cache security group. Applications using
562             ElastiCache must be running on Amazon EC2, and Amazon EC2 security
563             groups are used as the authorization mechanism.
564              
565             You cannot authorize ingress from an Amazon EC2 security group in one
566             region to an ElastiCache cluster in another region.
567              
568              
569             =head2 CopySnapshot(SourceSnapshotName => Str, TargetSnapshotName => Str, [TargetBucket => Str])
570              
571             Each argument is described in detail in: L<Paws::ElastiCache::CopySnapshot>
572              
573             Returns: a L<Paws::ElastiCache::CopySnapshotResult> instance
574              
575             Makes a copy of an existing snapshot.
576              
577             This operation is valid for Redis only.
578              
579             Users or groups that have permissions to use the C<CopySnapshot>
580             operation can create their own Amazon S3 buckets and copy snapshots to
581             it. To control access to your snapshots, use an IAM policy to control
582             who has the ability to use the C<CopySnapshot> operation. For more
583             information about using IAM to control the use of ElastiCache
584             operations, see Exporting Snapshots and Authentication & Access
585             Control.
586              
587             You could receive the following error messages.
588              
589             B<Error Messages>
590              
591             =over
592              
593             =item *
594              
595             B<Error Message:> The S3 bucket %s is outside of the region.
596              
597             B<Solution:> Create an Amazon S3 bucket in the same region as your
598             snapshot. For more information, see Step 1: Create an Amazon S3 Bucket
599             in the ElastiCache User Guide.
600              
601             =item *
602              
603             B<Error Message:> The S3 bucket %s does not exist.
604              
605             B<Solution:> Create an Amazon S3 bucket in the same region as your
606             snapshot. For more information, see Step 1: Create an Amazon S3 Bucket
607             in the ElastiCache User Guide.
608              
609             =item *
610              
611             B<Error Message:> The S3 bucket %s is not owned by the authenticated
612             user.
613              
614             B<Solution:> Create an Amazon S3 bucket in the same region as your
615             snapshot. For more information, see Step 1: Create an Amazon S3 Bucket
616             in the ElastiCache User Guide.
617              
618             =item *
619              
620             B<Error Message:> The authenticated user does not have sufficient
621             permissions to perform the desired activity.
622              
623             B<Solution:> Contact your system administrator to get the needed
624             permissions.
625              
626             =item *
627              
628             B<Error Message:> The S3 bucket %s already contains an object with key
629             %s.
630              
631             B<Solution:> Give the C<TargetSnapshotName> a new and unique value. If
632             exporting a snapshot, you could alternatively create a new Amazon S3
633             bucket and use this same value for C<TargetSnapshotName>.
634              
635             =item *
636              
637             B<Error Message: > ElastiCache has not been granted READ permissions %s
638             on the S3 Bucket.
639              
640             B<Solution:> Add List and Read permissions on the bucket. For more
641             information, see Step 2: Grant ElastiCache Access to Your Amazon S3
642             Bucket in the ElastiCache User Guide.
643              
644             =item *
645              
646             B<Error Message: > ElastiCache has not been granted WRITE permissions
647             %s on the S3 Bucket.
648              
649             B<Solution:> Add Upload/Delete permissions on the bucket. For more
650             information, see Step 2: Grant ElastiCache Access to Your Amazon S3
651             Bucket in the ElastiCache User Guide.
652              
653             =item *
654              
655             B<Error Message: > ElastiCache has not been granted READ_ACP
656             permissions %s on the S3 Bucket.
657              
658             B<Solution:> Add View Permissions on the bucket. For more information,
659             see Step 2: Grant ElastiCache Access to Your Amazon S3 Bucket in the
660             ElastiCache User Guide.
661              
662             =back
663              
664              
665              
666             =head2 CreateCacheCluster(CacheClusterId => Str, [AuthToken => Str, AutoMinorVersionUpgrade => Bool, AZMode => Str, CacheNodeType => Str, CacheParameterGroupName => Str, CacheSecurityGroupNames => ArrayRef[Str|Undef], CacheSubnetGroupName => Str, Engine => Str, EngineVersion => Str, NotificationTopicArn => Str, NumCacheNodes => Int, Port => Int, PreferredAvailabilityZone => Str, PreferredAvailabilityZones => ArrayRef[Str|Undef], PreferredMaintenanceWindow => Str, ReplicationGroupId => Str, SecurityGroupIds => ArrayRef[Str|Undef], SnapshotArns => ArrayRef[Str|Undef], SnapshotName => Str, SnapshotRetentionLimit => Int, SnapshotWindow => Str, Tags => ArrayRef[L<Paws::ElastiCache::Tag>]])
667              
668             Each argument is described in detail in: L<Paws::ElastiCache::CreateCacheCluster>
669              
670             Returns: a L<Paws::ElastiCache::CreateCacheClusterResult> instance
671              
672             Creates a cache cluster. All nodes in the cache cluster run the same
673             protocol-compliant cache engine software, either Memcached or Redis.
674              
675             Due to current limitations on Redis (cluster mode disabled), this
676             operation or parameter is not supported on Redis (cluster mode enabled)
677             replication groups.
678              
679              
680             =head2 CreateCacheParameterGroup(CacheParameterGroupFamily => Str, CacheParameterGroupName => Str, Description => Str)
681              
682             Each argument is described in detail in: L<Paws::ElastiCache::CreateCacheParameterGroup>
683              
684             Returns: a L<Paws::ElastiCache::CreateCacheParameterGroupResult> instance
685              
686             Creates a new Amazon ElastiCache cache parameter group. An ElastiCache
687             cache parameter group is a collection of parameters and their values
688             that are applied to all of the nodes in any cache cluster or
689             replication group using the CacheParameterGroup.
690              
691             A newly created CacheParameterGroup is an exact duplicate of the
692             default parameter group for the CacheParameterGroupFamily. To customize
693             the newly created CacheParameterGroup you can change the values of
694             specific parameters. For more information, see:
695              
696             =over
697              
698             =item *
699              
700             ModifyCacheParameterGroup in the ElastiCache API Reference.
701              
702             =item *
703              
704             Parameters and Parameter Groups in the ElastiCache User Guide.
705              
706             =back
707              
708              
709              
710             =head2 CreateCacheSecurityGroup(CacheSecurityGroupName => Str, Description => Str)
711              
712             Each argument is described in detail in: L<Paws::ElastiCache::CreateCacheSecurityGroup>
713              
714             Returns: a L<Paws::ElastiCache::CreateCacheSecurityGroupResult> instance
715              
716             Creates a new cache security group. Use a cache security group to
717             control access to one or more cache clusters.
718              
719             Cache security groups are only used when you are creating a cache
720             cluster outside of an Amazon Virtual Private Cloud (Amazon VPC). If you
721             are creating a cache cluster inside of a VPC, use a cache subnet group
722             instead. For more information, see CreateCacheSubnetGroup.
723              
724              
725             =head2 CreateCacheSubnetGroup(CacheSubnetGroupDescription => Str, CacheSubnetGroupName => Str, SubnetIds => ArrayRef[Str|Undef])
726              
727             Each argument is described in detail in: L<Paws::ElastiCache::CreateCacheSubnetGroup>
728              
729             Returns: a L<Paws::ElastiCache::CreateCacheSubnetGroupResult> instance
730              
731             Creates a new cache subnet group.
732              
733             Use this parameter only when you are creating a cluster in an Amazon
734             Virtual Private Cloud (Amazon VPC).
735              
736              
737             =head2 CreateReplicationGroup(ReplicationGroupDescription => Str, ReplicationGroupId => Str, [AuthToken => Str, AutomaticFailoverEnabled => Bool, AutoMinorVersionUpgrade => Bool, CacheNodeType => Str, CacheParameterGroupName => Str, CacheSecurityGroupNames => ArrayRef[Str|Undef], CacheSubnetGroupName => Str, Engine => Str, EngineVersion => Str, NodeGroupConfiguration => ArrayRef[L<Paws::ElastiCache::NodeGroupConfiguration>], NotificationTopicArn => Str, NumCacheClusters => Int, NumNodeGroups => Int, Port => Int, PreferredCacheClusterAZs => ArrayRef[Str|Undef], PreferredMaintenanceWindow => Str, PrimaryClusterId => Str, ReplicasPerNodeGroup => Int, SecurityGroupIds => ArrayRef[Str|Undef], SnapshotArns => ArrayRef[Str|Undef], SnapshotName => Str, SnapshotRetentionLimit => Int, SnapshotWindow => Str, Tags => ArrayRef[L<Paws::ElastiCache::Tag>]])
738              
739             Each argument is described in detail in: L<Paws::ElastiCache::CreateReplicationGroup>
740              
741             Returns: a L<Paws::ElastiCache::CreateReplicationGroupResult> instance
742              
743             Creates a Redis (cluster mode disabled) or a Redis (cluster mode
744             enabled) replication group.
745              
746             A Redis (cluster mode disabled) replication group is a collection of
747             cache clusters, where one of the cache clusters is a read/write primary
748             and the others are read-only replicas. Writes to the primary are
749             asynchronously propagated to the replicas.
750              
751             A Redis (cluster mode enabled) replication group is a collection of 1
752             to 15 node groups (shards). Each node group (shard) has one read/write
753             primary node and up to 5 read-only replica nodes. Writes to the primary
754             are asynchronously propagated to the replicas. Redis (cluster mode
755             enabled) replication groups partition the data across node groups
756             (shards).
757              
758             When a Redis (cluster mode disabled) replication group has been
759             successfully created, you can add one or more read replicas to it, up
760             to a total of 5 read replicas. You cannot alter a Redis (cluster mode
761             enabled) replication group after it has been created. However, if you
762             need to increase or decrease the number of node groups (console:
763             shards), you can avail yourself of ElastiCache for Redis' enhanced
764             backup and restore. For more information, see Restoring From a Backup
765             with Cluster Resizing in the I<ElastiCache User Guide>.
766              
767             This operation is valid for Redis only.
768              
769              
770             =head2 CreateSnapshot(SnapshotName => Str, [CacheClusterId => Str, ReplicationGroupId => Str])
771              
772             Each argument is described in detail in: L<Paws::ElastiCache::CreateSnapshot>
773              
774             Returns: a L<Paws::ElastiCache::CreateSnapshotResult> instance
775              
776             Creates a copy of an entire cache cluster or replication group at a
777             specific moment in time.
778              
779             This operation is valid for Redis only.
780              
781              
782             =head2 DeleteCacheCluster(CacheClusterId => Str, [FinalSnapshotIdentifier => Str])
783              
784             Each argument is described in detail in: L<Paws::ElastiCache::DeleteCacheCluster>
785              
786             Returns: a L<Paws::ElastiCache::DeleteCacheClusterResult> instance
787              
788             Deletes a previously provisioned cache cluster. C<DeleteCacheCluster>
789             deletes all associated cache nodes, node endpoints and the cache
790             cluster itself. When you receive a successful response from this
791             operation, Amazon ElastiCache immediately begins deleting the cache
792             cluster; you cannot cancel or revert this operation.
793              
794             This operation cannot be used to delete a cache cluster that is the
795             last read replica of a replication group or node group (shard) that has
796             Multi-AZ mode enabled or a cache cluster from a Redis (cluster mode
797             enabled) replication group.
798              
799             Due to current limitations on Redis (cluster mode disabled), this
800             operation or parameter is not supported on Redis (cluster mode enabled)
801             replication groups.
802              
803              
804             =head2 DeleteCacheParameterGroup(CacheParameterGroupName => Str)
805              
806             Each argument is described in detail in: L<Paws::ElastiCache::DeleteCacheParameterGroup>
807              
808             Returns: nothing
809              
810             Deletes the specified cache parameter group. You cannot delete a cache
811             parameter group if it is associated with any cache clusters.
812              
813              
814             =head2 DeleteCacheSecurityGroup(CacheSecurityGroupName => Str)
815              
816             Each argument is described in detail in: L<Paws::ElastiCache::DeleteCacheSecurityGroup>
817              
818             Returns: nothing
819              
820             Deletes a cache security group.
821              
822             You cannot delete a cache security group if it is associated with any
823             cache clusters.
824              
825              
826             =head2 DeleteCacheSubnetGroup(CacheSubnetGroupName => Str)
827              
828             Each argument is described in detail in: L<Paws::ElastiCache::DeleteCacheSubnetGroup>
829              
830             Returns: nothing
831              
832             Deletes a cache subnet group.
833              
834             You cannot delete a cache subnet group if it is associated with any
835             cache clusters.
836              
837              
838             =head2 DeleteReplicationGroup(ReplicationGroupId => Str, [FinalSnapshotIdentifier => Str, RetainPrimaryCluster => Bool])
839              
840             Each argument is described in detail in: L<Paws::ElastiCache::DeleteReplicationGroup>
841              
842             Returns: a L<Paws::ElastiCache::DeleteReplicationGroupResult> instance
843              
844             Deletes an existing replication group. By default, this operation
845             deletes the entire replication group, including the primary/primaries
846             and all of the read replicas. If the replication group has only one
847             primary, you can optionally delete only the read replicas, while
848             retaining the primary by setting C<RetainPrimaryCluster=true>.
849              
850             When you receive a successful response from this operation, Amazon
851             ElastiCache immediately begins deleting the selected resources; you
852             cannot cancel or revert this operation.
853              
854             This operation is valid for Redis only.
855              
856              
857             =head2 DeleteSnapshot(SnapshotName => Str)
858              
859             Each argument is described in detail in: L<Paws::ElastiCache::DeleteSnapshot>
860              
861             Returns: a L<Paws::ElastiCache::DeleteSnapshotResult> instance
862              
863             Deletes an existing snapshot. When you receive a successful response
864             from this operation, ElastiCache immediately begins deleting the
865             snapshot; you cannot cancel or revert this operation.
866              
867             This operation is valid for Redis only.
868              
869              
870             =head2 DescribeCacheClusters([CacheClusterId => Str, Marker => Str, MaxRecords => Int, ShowCacheClustersNotInReplicationGroups => Bool, ShowCacheNodeInfo => Bool])
871              
872             Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheClusters>
873              
874             Returns: a L<Paws::ElastiCache::CacheClusterMessage> instance
875              
876             Returns information about all provisioned cache clusters if no cache
877             cluster identifier is specified, or about a specific cache cluster if a
878             cache cluster identifier is supplied.
879              
880             By default, abbreviated information about the cache clusters is
881             returned. You can use the optional I<ShowCacheNodeInfo> flag to
882             retrieve detailed information about the cache nodes associated with the
883             cache clusters. These details include the DNS address and port for the
884             cache node endpoint.
885              
886             If the cluster is in the I<creating> state, only cluster-level
887             information is displayed until all of the nodes are successfully
888             provisioned.
889              
890             If the cluster is in the I<deleting> state, only cluster-level
891             information is displayed.
892              
893             If cache nodes are currently being added to the cache cluster, node
894             endpoint information and creation time for the additional nodes are not
895             displayed until they are completely provisioned. When the cache cluster
896             state is I<available>, the cluster is ready for use.
897              
898             If cache nodes are currently being removed from the cache cluster, no
899             endpoint information for the removed nodes is displayed.
900              
901              
902             =head2 DescribeCacheEngineVersions([CacheParameterGroupFamily => Str, DefaultOnly => Bool, Engine => Str, EngineVersion => Str, Marker => Str, MaxRecords => Int])
903              
904             Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheEngineVersions>
905              
906             Returns: a L<Paws::ElastiCache::CacheEngineVersionMessage> instance
907              
908             Returns a list of the available cache engines and their versions.
909              
910              
911             =head2 DescribeCacheParameterGroups([CacheParameterGroupName => Str, Marker => Str, MaxRecords => Int])
912              
913             Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheParameterGroups>
914              
915             Returns: a L<Paws::ElastiCache::CacheParameterGroupsMessage> instance
916              
917             Returns a list of cache parameter group descriptions. If a cache
918             parameter group name is specified, the list contains only the
919             descriptions for that group.
920              
921              
922             =head2 DescribeCacheParameters(CacheParameterGroupName => Str, [Marker => Str, MaxRecords => Int, Source => Str])
923              
924             Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheParameters>
925              
926             Returns: a L<Paws::ElastiCache::CacheParameterGroupDetails> instance
927              
928             Returns the detailed parameter list for a particular cache parameter
929             group.
930              
931              
932             =head2 DescribeCacheSecurityGroups([CacheSecurityGroupName => Str, Marker => Str, MaxRecords => Int])
933              
934             Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheSecurityGroups>
935              
936             Returns: a L<Paws::ElastiCache::CacheSecurityGroupMessage> instance
937              
938             Returns a list of cache security group descriptions. If a cache
939             security group name is specified, the list contains only the
940             description of that group.
941              
942              
943             =head2 DescribeCacheSubnetGroups([CacheSubnetGroupName => Str, Marker => Str, MaxRecords => Int])
944              
945             Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheSubnetGroups>
946              
947             Returns: a L<Paws::ElastiCache::CacheSubnetGroupMessage> instance
948              
949             Returns a list of cache subnet group descriptions. If a subnet group
950             name is specified, the list contains only the description of that
951             group.
952              
953              
954             =head2 DescribeEngineDefaultParameters(CacheParameterGroupFamily => Str, [Marker => Str, MaxRecords => Int])
955              
956             Each argument is described in detail in: L<Paws::ElastiCache::DescribeEngineDefaultParameters>
957              
958             Returns: a L<Paws::ElastiCache::DescribeEngineDefaultParametersResult> instance
959              
960             Returns the default engine and system parameter information for the
961             specified cache engine.
962              
963              
964             =head2 DescribeEvents([Duration => Int, EndTime => Str, Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
965              
966             Each argument is described in detail in: L<Paws::ElastiCache::DescribeEvents>
967              
968             Returns: a L<Paws::ElastiCache::EventsMessage> instance
969              
970             Returns events related to cache clusters, cache security groups, and
971             cache parameter groups. You can obtain events specific to a particular
972             cache cluster, cache security group, or cache parameter group by
973             providing the name as a parameter.
974              
975             By default, only the events occurring within the last hour are
976             returned; however, you can retrieve up to 14 days' worth of events if
977             necessary.
978              
979              
980             =head2 DescribeReplicationGroups([Marker => Str, MaxRecords => Int, ReplicationGroupId => Str])
981              
982             Each argument is described in detail in: L<Paws::ElastiCache::DescribeReplicationGroups>
983              
984             Returns: a L<Paws::ElastiCache::ReplicationGroupMessage> instance
985              
986             Returns information about a particular replication group. If no
987             identifier is specified, C<DescribeReplicationGroups> returns
988             information about all replication groups.
989              
990             This operation is valid for Redis only.
991              
992              
993             =head2 DescribeReservedCacheNodes([CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodeId => Str, ReservedCacheNodesOfferingId => Str])
994              
995             Each argument is described in detail in: L<Paws::ElastiCache::DescribeReservedCacheNodes>
996              
997             Returns: a L<Paws::ElastiCache::ReservedCacheNodeMessage> instance
998              
999             Returns information about reserved cache nodes for this account, or
1000             about a specified reserved cache node.
1001              
1002              
1003             =head2 DescribeReservedCacheNodesOfferings([CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodesOfferingId => Str])
1004              
1005             Each argument is described in detail in: L<Paws::ElastiCache::DescribeReservedCacheNodesOfferings>
1006              
1007             Returns: a L<Paws::ElastiCache::ReservedCacheNodesOfferingMessage> instance
1008              
1009             Lists available reserved cache node offerings.
1010              
1011              
1012             =head2 DescribeSnapshots([CacheClusterId => Str, Marker => Str, MaxRecords => Int, ReplicationGroupId => Str, ShowNodeGroupConfig => Bool, SnapshotName => Str, SnapshotSource => Str])
1013              
1014             Each argument is described in detail in: L<Paws::ElastiCache::DescribeSnapshots>
1015              
1016             Returns: a L<Paws::ElastiCache::DescribeSnapshotsListMessage> instance
1017              
1018             Returns information about cache cluster or replication group snapshots.
1019             By default, C<DescribeSnapshots> lists all of your snapshots; it can
1020             optionally describe a single snapshot, or just the snapshots associated
1021             with a particular cache cluster.
1022              
1023             This operation is valid for Redis only.
1024              
1025              
1026             =head2 ListAllowedNodeTypeModifications([CacheClusterId => Str, ReplicationGroupId => Str])
1027              
1028             Each argument is described in detail in: L<Paws::ElastiCache::ListAllowedNodeTypeModifications>
1029              
1030             Returns: a L<Paws::ElastiCache::AllowedNodeTypeModificationsMessage> instance
1031              
1032             Lists all available node types that you can scale your Redis cluster's
1033             or replication group's current node type up to.
1034              
1035             When you use the C<ModifyCacheCluster> or C<ModifyReplicationGroup>
1036             operations to scale up your cluster or replication group, the value of
1037             the C<CacheNodeType> parameter must be one of the node types returned
1038             by this operation.
1039              
1040              
1041             =head2 ListTagsForResource(ResourceName => Str)
1042              
1043             Each argument is described in detail in: L<Paws::ElastiCache::ListTagsForResource>
1044              
1045             Returns: a L<Paws::ElastiCache::TagListMessage> instance
1046              
1047             Lists all cost allocation tags currently on the named resource. A
1048             C<cost allocation tag> is a key-value pair where the key is
1049             case-sensitive and the value is optional. You can use cost allocation
1050             tags to categorize and track your AWS costs.
1051              
1052             You can have a maximum of 50 cost allocation tags on an ElastiCache
1053             resource. For more information, see Using Cost Allocation Tags in
1054             Amazon ElastiCache.
1055              
1056              
1057             =head2 ModifyCacheCluster(CacheClusterId => Str, [ApplyImmediately => Bool, AutoMinorVersionUpgrade => Bool, AZMode => Str, CacheNodeIdsToRemove => ArrayRef[Str|Undef], CacheNodeType => Str, CacheParameterGroupName => Str, CacheSecurityGroupNames => ArrayRef[Str|Undef], EngineVersion => Str, NewAvailabilityZones => ArrayRef[Str|Undef], NotificationTopicArn => Str, NotificationTopicStatus => Str, NumCacheNodes => Int, PreferredMaintenanceWindow => Str, SecurityGroupIds => ArrayRef[Str|Undef], SnapshotRetentionLimit => Int, SnapshotWindow => Str])
1058              
1059             Each argument is described in detail in: L<Paws::ElastiCache::ModifyCacheCluster>
1060              
1061             Returns: a L<Paws::ElastiCache::ModifyCacheClusterResult> instance
1062              
1063             Modifies the settings for a cache cluster. You can use this operation
1064             to change one or more cluster configuration parameters by specifying
1065             the parameters and the new values.
1066              
1067              
1068             =head2 ModifyCacheParameterGroup(CacheParameterGroupName => Str, ParameterNameValues => ArrayRef[L<Paws::ElastiCache::ParameterNameValue>])
1069              
1070             Each argument is described in detail in: L<Paws::ElastiCache::ModifyCacheParameterGroup>
1071              
1072             Returns: a L<Paws::ElastiCache::CacheParameterGroupNameMessage> instance
1073              
1074             Modifies the parameters of a cache parameter group. You can modify up
1075             to 20 parameters in a single request by submitting a list parameter
1076             name and value pairs.
1077              
1078              
1079             =head2 ModifyCacheSubnetGroup(CacheSubnetGroupName => Str, [CacheSubnetGroupDescription => Str, SubnetIds => ArrayRef[Str|Undef]])
1080              
1081             Each argument is described in detail in: L<Paws::ElastiCache::ModifyCacheSubnetGroup>
1082              
1083             Returns: a L<Paws::ElastiCache::ModifyCacheSubnetGroupResult> instance
1084              
1085             Modifies an existing cache subnet group.
1086              
1087              
1088             =head2 ModifyReplicationGroup(ReplicationGroupId => Str, [ApplyImmediately => Bool, AutomaticFailoverEnabled => Bool, AutoMinorVersionUpgrade => Bool, CacheNodeType => Str, CacheParameterGroupName => Str, CacheSecurityGroupNames => ArrayRef[Str|Undef], EngineVersion => Str, NodeGroupId => Str, NotificationTopicArn => Str, NotificationTopicStatus => Str, PreferredMaintenanceWindow => Str, PrimaryClusterId => Str, ReplicationGroupDescription => Str, SecurityGroupIds => ArrayRef[Str|Undef], SnapshotRetentionLimit => Int, SnapshottingClusterId => Str, SnapshotWindow => Str])
1089              
1090             Each argument is described in detail in: L<Paws::ElastiCache::ModifyReplicationGroup>
1091              
1092             Returns: a L<Paws::ElastiCache::ModifyReplicationGroupResult> instance
1093              
1094             Modifies the settings for a replication group.
1095              
1096             Due to current limitations on Redis (cluster mode disabled), this
1097             operation or parameter is not supported on Redis (cluster mode enabled)
1098             replication groups.
1099              
1100             This operation is valid for Redis only.
1101              
1102              
1103             =head2 PurchaseReservedCacheNodesOffering(ReservedCacheNodesOfferingId => Str, [CacheNodeCount => Int, ReservedCacheNodeId => Str])
1104              
1105             Each argument is described in detail in: L<Paws::ElastiCache::PurchaseReservedCacheNodesOffering>
1106              
1107             Returns: a L<Paws::ElastiCache::PurchaseReservedCacheNodesOfferingResult> instance
1108              
1109             Allows you to purchase a reserved cache node offering.
1110              
1111              
1112             =head2 RebootCacheCluster(CacheClusterId => Str, CacheNodeIdsToReboot => ArrayRef[Str|Undef])
1113              
1114             Each argument is described in detail in: L<Paws::ElastiCache::RebootCacheCluster>
1115              
1116             Returns: a L<Paws::ElastiCache::RebootCacheClusterResult> instance
1117              
1118             Reboots some, or all, of the cache nodes within a provisioned cache
1119             cluster. This operation applies any modified cache parameter groups to
1120             the cache cluster. The reboot operation takes place as soon as
1121             possible, and results in a momentary outage to the cache cluster.
1122             During the reboot, the cache cluster status is set to REBOOTING.
1123              
1124             The reboot causes the contents of the cache (for each cache node being
1125             rebooted) to be lost.
1126              
1127             When the reboot is complete, a cache cluster event is created.
1128              
1129              
1130             =head2 RemoveTagsFromResource(ResourceName => Str, TagKeys => ArrayRef[Str|Undef])
1131              
1132             Each argument is described in detail in: L<Paws::ElastiCache::RemoveTagsFromResource>
1133              
1134             Returns: a L<Paws::ElastiCache::TagListMessage> instance
1135              
1136             Removes the tags identified by the C<TagKeys> list from the named
1137             resource.
1138              
1139              
1140             =head2 ResetCacheParameterGroup(CacheParameterGroupName => Str, [ParameterNameValues => ArrayRef[L<Paws::ElastiCache::ParameterNameValue>], ResetAllParameters => Bool])
1141              
1142             Each argument is described in detail in: L<Paws::ElastiCache::ResetCacheParameterGroup>
1143              
1144             Returns: a L<Paws::ElastiCache::CacheParameterGroupNameMessage> instance
1145              
1146             Modifies the parameters of a cache parameter group to the engine or
1147             system default value. You can reset specific parameters by submitting a
1148             list of parameter names. To reset the entire cache parameter group,
1149             specify the C<ResetAllParameters> and C<CacheParameterGroupName>
1150             parameters.
1151              
1152              
1153             =head2 RevokeCacheSecurityGroupIngress(CacheSecurityGroupName => Str, EC2SecurityGroupName => Str, EC2SecurityGroupOwnerId => Str)
1154              
1155             Each argument is described in detail in: L<Paws::ElastiCache::RevokeCacheSecurityGroupIngress>
1156              
1157             Returns: a L<Paws::ElastiCache::RevokeCacheSecurityGroupIngressResult> instance
1158              
1159             Revokes ingress from a cache security group. Use this operation to
1160             disallow access from an Amazon EC2 security group that had been
1161             previously authorized.
1162              
1163              
1164             =head2 TestFailover(NodeGroupId => Str, ReplicationGroupId => Str)
1165              
1166             Each argument is described in detail in: L<Paws::ElastiCache::TestFailover>
1167              
1168             Returns: a L<Paws::ElastiCache::TestFailoverResult> instance
1169              
1170             Represents the input of a C<TestFailover> operation which test
1171             automatic failover on a specified node group (called shard in the
1172             console) in a replication group (called cluster in the console).
1173              
1174             B<Note the following>
1175              
1176             =over
1177              
1178             =item *
1179              
1180             A customer can use this operation to test automatic failover on up to 5
1181             shards (called node groups in the ElastiCache API and AWS CLI) in any
1182             rolling 24-hour period.
1183              
1184             =item *
1185              
1186             If calling this operation on shards in different clusters (called
1187             replication groups in the API and CLI), the calls can be made
1188             concurrently.
1189              
1190             =item *
1191              
1192             If calling this operation multiple times on different shards in the
1193             same Redis (cluster mode enabled) replication group, the first node
1194             replacement must complete before a subsequent call can be made.
1195              
1196             =item *
1197              
1198             To determine whether the node replacement is complete you can check
1199             Events using the Amazon ElastiCache console, the AWS CLI, or the
1200             ElastiCache API. Look for the following automatic failover related
1201             events, listed here in order of occurrance:
1202              
1203             =over
1204              
1205             =item 1.
1206              
1207             Replication group message: C<Test Failover API called for node group
1208             E<lt>node-group-idE<gt>>
1209              
1210             =item 2.
1211              
1212             Cache cluster message: C<Failover from master node
1213             E<lt>primary-node-idE<gt> to replica node E<lt>node-idE<gt> completed>
1214              
1215             =item 3.
1216              
1217             Replication group message: C<Failover from master node
1218             E<lt>primary-node-idE<gt> to replica node E<lt>node-idE<gt> completed>
1219              
1220             =item 4.
1221              
1222             Cache cluster message: C<Recovering cache nodes E<lt>node-idE<gt>>
1223              
1224             =item 5.
1225              
1226             Cache cluster message: C<Finished recovery for cache nodes
1227             E<lt>node-idE<gt>>
1228              
1229             =back
1230              
1231             For more information see:
1232              
1233             =over
1234              
1235             =item *
1236              
1237             Viewing ElastiCache Events in the I<ElastiCache User Guide>
1238              
1239             =item *
1240              
1241             DescribeEvents in the ElastiCache API Reference
1242              
1243             =back
1244              
1245             =back
1246              
1247             Also see, Testing Multi-AZ with Automatic Failover in the I<ElastiCache
1248             User Guide>.
1249              
1250              
1251              
1252              
1253             =head1 PAGINATORS
1254              
1255             Paginator methods are helpers that repetively call methods that return partial results
1256              
1257             =head2 DescribeAllCacheClusters(sub { },[CacheClusterId => Str, Marker => Str, MaxRecords => Int, ShowCacheClustersNotInReplicationGroups => Bool, ShowCacheNodeInfo => Bool])
1258              
1259             =head2 DescribeAllCacheClusters([CacheClusterId => Str, Marker => Str, MaxRecords => Int, ShowCacheClustersNotInReplicationGroups => Bool, ShowCacheNodeInfo => Bool])
1260              
1261              
1262             If passed a sub as first parameter, it will call the sub for each element found in :
1263              
1264             - CacheClusters, passing the object as the first parameter, and the string 'CacheClusters' as the second parameter
1265              
1266             If not, it will return a a L<Paws::ElastiCache::CacheClusterMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1267              
1268              
1269             =head2 DescribeAllCacheEngineVersions(sub { },[CacheParameterGroupFamily => Str, DefaultOnly => Bool, Engine => Str, EngineVersion => Str, Marker => Str, MaxRecords => Int])
1270              
1271             =head2 DescribeAllCacheEngineVersions([CacheParameterGroupFamily => Str, DefaultOnly => Bool, Engine => Str, EngineVersion => Str, Marker => Str, MaxRecords => Int])
1272              
1273              
1274             If passed a sub as first parameter, it will call the sub for each element found in :
1275              
1276             - CacheEngineVersions, passing the object as the first parameter, and the string 'CacheEngineVersions' as the second parameter
1277              
1278             If not, it will return a a L<Paws::ElastiCache::CacheEngineVersionMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1279              
1280              
1281             =head2 DescribeAllCacheParameterGroups(sub { },[CacheParameterGroupName => Str, Marker => Str, MaxRecords => Int])
1282              
1283             =head2 DescribeAllCacheParameterGroups([CacheParameterGroupName => Str, Marker => Str, MaxRecords => Int])
1284              
1285              
1286             If passed a sub as first parameter, it will call the sub for each element found in :
1287              
1288             - CacheParameterGroups, passing the object as the first parameter, and the string 'CacheParameterGroups' as the second parameter
1289              
1290             If not, it will return a a L<Paws::ElastiCache::CacheParameterGroupsMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1291              
1292              
1293             =head2 DescribeAllCacheParameters(sub { },CacheParameterGroupName => Str, [Marker => Str, MaxRecords => Int, Source => Str])
1294              
1295             =head2 DescribeAllCacheParameters(CacheParameterGroupName => Str, [Marker => Str, MaxRecords => Int, Source => Str])
1296              
1297              
1298             If passed a sub as first parameter, it will call the sub for each element found in :
1299              
1300             - Parameters, passing the object as the first parameter, and the string 'Parameters' as the second parameter
1301              
1302             If not, it will return a a L<Paws::ElastiCache::CacheParameterGroupDetails> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1303              
1304              
1305             =head2 DescribeAllCacheSecurityGroups(sub { },[CacheSecurityGroupName => Str, Marker => Str, MaxRecords => Int])
1306              
1307             =head2 DescribeAllCacheSecurityGroups([CacheSecurityGroupName => Str, Marker => Str, MaxRecords => Int])
1308              
1309              
1310             If passed a sub as first parameter, it will call the sub for each element found in :
1311              
1312             - CacheSecurityGroups, passing the object as the first parameter, and the string 'CacheSecurityGroups' as the second parameter
1313              
1314             If not, it will return a a L<Paws::ElastiCache::CacheSecurityGroupMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1315              
1316              
1317             =head2 DescribeAllCacheSubnetGroups(sub { },[CacheSubnetGroupName => Str, Marker => Str, MaxRecords => Int])
1318              
1319             =head2 DescribeAllCacheSubnetGroups([CacheSubnetGroupName => Str, Marker => Str, MaxRecords => Int])
1320              
1321              
1322             If passed a sub as first parameter, it will call the sub for each element found in :
1323              
1324             - CacheSubnetGroups, passing the object as the first parameter, and the string 'CacheSubnetGroups' as the second parameter
1325              
1326             If not, it will return a a L<Paws::ElastiCache::CacheSubnetGroupMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1327              
1328              
1329             =head2 DescribeAllEngineDefaultParameters(sub { },CacheParameterGroupFamily => Str, [Marker => Str, MaxRecords => Int])
1330              
1331             =head2 DescribeAllEngineDefaultParameters(CacheParameterGroupFamily => Str, [Marker => Str, MaxRecords => Int])
1332              
1333              
1334             If passed a sub as first parameter, it will call the sub for each element found in :
1335              
1336             - EngineDefaults.Parameters, passing the object as the first parameter, and the string 'EngineDefaults.Parameters' as the second parameter
1337              
1338             If not, it will return a a L<Paws::ElastiCache::DescribeEngineDefaultParametersResult> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1339              
1340              
1341             =head2 DescribeAllEvents(sub { },[Duration => Int, EndTime => Str, Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
1342              
1343             =head2 DescribeAllEvents([Duration => Int, EndTime => Str, Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
1344              
1345              
1346             If passed a sub as first parameter, it will call the sub for each element found in :
1347              
1348             - Events, passing the object as the first parameter, and the string 'Events' as the second parameter
1349              
1350             If not, it will return a a L<Paws::ElastiCache::EventsMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1351              
1352              
1353             =head2 DescribeAllReplicationGroups(sub { },[Marker => Str, MaxRecords => Int, ReplicationGroupId => Str])
1354              
1355             =head2 DescribeAllReplicationGroups([Marker => Str, MaxRecords => Int, ReplicationGroupId => Str])
1356              
1357              
1358             If passed a sub as first parameter, it will call the sub for each element found in :
1359              
1360             - ReplicationGroups, passing the object as the first parameter, and the string 'ReplicationGroups' as the second parameter
1361              
1362             If not, it will return a a L<Paws::ElastiCache::ReplicationGroupMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1363              
1364              
1365             =head2 DescribeAllReservedCacheNodes(sub { },[CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodeId => Str, ReservedCacheNodesOfferingId => Str])
1366              
1367             =head2 DescribeAllReservedCacheNodes([CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodeId => Str, ReservedCacheNodesOfferingId => Str])
1368              
1369              
1370             If passed a sub as first parameter, it will call the sub for each element found in :
1371              
1372             - ReservedCacheNodes, passing the object as the first parameter, and the string 'ReservedCacheNodes' as the second parameter
1373              
1374             If not, it will return a a L<Paws::ElastiCache::ReservedCacheNodeMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1375              
1376              
1377             =head2 DescribeAllReservedCacheNodesOfferings(sub { },[CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodesOfferingId => Str])
1378              
1379             =head2 DescribeAllReservedCacheNodesOfferings([CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodesOfferingId => Str])
1380              
1381              
1382             If passed a sub as first parameter, it will call the sub for each element found in :
1383              
1384             - ReservedCacheNodesOfferings, passing the object as the first parameter, and the string 'ReservedCacheNodesOfferings' as the second parameter
1385              
1386             If not, it will return a a L<Paws::ElastiCache::ReservedCacheNodesOfferingMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1387              
1388              
1389             =head2 DescribeAllSnapshots(sub { },[CacheClusterId => Str, Marker => Str, MaxRecords => Int, ReplicationGroupId => Str, ShowNodeGroupConfig => Bool, SnapshotName => Str, SnapshotSource => Str])
1390              
1391             =head2 DescribeAllSnapshots([CacheClusterId => Str, Marker => Str, MaxRecords => Int, ReplicationGroupId => Str, ShowNodeGroupConfig => Bool, SnapshotName => Str, SnapshotSource => Str])
1392              
1393              
1394             If passed a sub as first parameter, it will call the sub for each element found in :
1395              
1396             - Snapshots, passing the object as the first parameter, and the string 'Snapshots' as the second parameter
1397              
1398             If not, it will return a a L<Paws::ElastiCache::DescribeSnapshotsListMessage> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1399              
1400              
1401              
1402              
1403              
1404             =head1 SEE ALSO
1405              
1406             This service class forms part of L<Paws>
1407              
1408             =head1 BUGS and CONTRIBUTIONS
1409              
1410             The source code is located here: https://github.com/pplu/aws-sdk-perl
1411              
1412             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
1413              
1414             =cut
1415