blib/lib/Paws/ElastiCache.pm untested

filter: Statementstmt 0.0% 0 / 548 Branchbran 0.0% 0 / 68 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 88 Podpod 0.0% 0 / 87 totaltotal 0.0% 0 / 791 CC 35 SCAR 18.2
CC
35
Cov
0%
DescribeAllCacheClusters
12.0
DescribeAllCacheEngineVersions
12.0
DescribeAllCacheParameterGroups
12.0
CRAP 6.2
1 package Paws::ElastiCache;
2 use Moose;
3 sub service { 'elasticache' }
4 sub signing_name { 'elasticache' }
5 sub version { '2015-02-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::QueryCaller';
15  
16
17 sub AddTagsToResource {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::ElastiCache::AddTagsToResource', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub AuthorizeCacheSecurityGroupIngress {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::ElastiCache::AuthorizeCacheSecurityGroupIngress', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub BatchApplyUpdateAction {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::ElastiCache::BatchApplyUpdateAction', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub BatchStopUpdateAction {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::ElastiCache::BatchStopUpdateAction', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub CompleteMigration {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CompleteMigration', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub CopySnapshot {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CopySnapshot', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub CreateCacheCluster {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateCacheCluster', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub CreateCacheParameterGroup {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateCacheParameterGroup', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub CreateCacheSecurityGroup {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateCacheSecurityGroup', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub CreateCacheSubnetGroup {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateCacheSubnetGroup', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub CreateGlobalReplicationGroup {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateGlobalReplicationGroup', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub CreateReplicationGroup {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateReplicationGroup', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77 sub CreateSnapshot {
78 my $self = shift;
79 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateSnapshot', @_);
80 return $self->caller->do_call($self, $call_object);
81 }
82 sub CreateUser {
83 my $self = shift;
84 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateUser', @_);
85 return $self->caller->do_call($self, $call_object);
86 }
87 sub CreateUserGroup {
88 my $self = shift;
89 my $call_object = $self->new_with_coercions('Paws::ElastiCache::CreateUserGroup', @_);
90 return $self->caller->do_call($self, $call_object);
91 }
92 sub DecreaseNodeGroupsInGlobalReplicationGroup {
93 my $self = shift;
94 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DecreaseNodeGroupsInGlobalReplicationGroup', @_);
95 return $self->caller->do_call($self, $call_object);
96 }
97 sub DecreaseReplicaCount {
98 my $self = shift;
99 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DecreaseReplicaCount', @_);
100 return $self->caller->do_call($self, $call_object);
101 }
102 sub DeleteCacheCluster {
103 my $self = shift;
104 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteCacheCluster', @_);
105 return $self->caller->do_call($self, $call_object);
106 }
107 sub DeleteCacheParameterGroup {
108 my $self = shift;
109 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteCacheParameterGroup', @_);
110 return $self->caller->do_call($self, $call_object);
111 }
112 sub DeleteCacheSecurityGroup {
113 my $self = shift;
114 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteCacheSecurityGroup', @_);
115 return $self->caller->do_call($self, $call_object);
116 }
117 sub DeleteCacheSubnetGroup {
118 my $self = shift;
119 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteCacheSubnetGroup', @_);
120 return $self->caller->do_call($self, $call_object);
121 }
122 sub DeleteGlobalReplicationGroup {
123 my $self = shift;
124 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteGlobalReplicationGroup', @_);
125 return $self->caller->do_call($self, $call_object);
126 }
127 sub DeleteReplicationGroup {
128 my $self = shift;
129 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteReplicationGroup', @_);
130 return $self->caller->do_call($self, $call_object);
131 }
132 sub DeleteSnapshot {
133 my $self = shift;
134 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteSnapshot', @_);
135 return $self->caller->do_call($self, $call_object);
136 }
137 sub DeleteUser {
138 my $self = shift;
139 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteUser', @_);
140 return $self->caller->do_call($self, $call_object);
141 }
142 sub DeleteUserGroup {
143 my $self = shift;
144 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DeleteUserGroup', @_);
145 return $self->caller->do_call($self, $call_object);
146 }
147 sub DescribeCacheClusters {
148 my $self = shift;
149 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheClusters', @_);
150 return $self->caller->do_call($self, $call_object);
151 }
152 sub DescribeCacheEngineVersions {
153 my $self = shift;
154 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheEngineVersions', @_);
155 return $self->caller->do_call($self, $call_object);
156 }
157 sub DescribeCacheParameterGroups {
158 my $self = shift;
159 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheParameterGroups', @_);
160 return $self->caller->do_call($self, $call_object);
161 }
162 sub DescribeCacheParameters {
163 my $self = shift;
164 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheParameters', @_);
165 return $self->caller->do_call($self, $call_object);
166 }
167 sub DescribeCacheSecurityGroups {
168 my $self = shift;
169 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheSecurityGroups', @_);
170 return $self->caller->do_call($self, $call_object);
171 }
172 sub DescribeCacheSubnetGroups {
173 my $self = shift;
174 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeCacheSubnetGroups', @_);
175 return $self->caller->do_call($self, $call_object);
176 }
177 sub DescribeEngineDefaultParameters {
178 my $self = shift;
179 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeEngineDefaultParameters', @_);
180 return $self->caller->do_call($self, $call_object);
181 }
182 sub DescribeEvents {
183 my $self = shift;
184 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeEvents', @_);
185 return $self->caller->do_call($self, $call_object);
186 }
187 sub DescribeGlobalReplicationGroups {
188 my $self = shift;
189 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeGlobalReplicationGroups', @_);
190 return $self->caller->do_call($self, $call_object);
191 }
192 sub DescribeReplicationGroups {
193 my $self = shift;
194 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeReplicationGroups', @_);
195 return $self->caller->do_call($self, $call_object);
196 }
197 sub DescribeReservedCacheNodes {
198 my $self = shift;
199 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeReservedCacheNodes', @_);
200 return $self->caller->do_call($self, $call_object);
201 }
202 sub DescribeReservedCacheNodesOfferings {
203 my $self = shift;
204 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeReservedCacheNodesOfferings', @_);
205 return $self->caller->do_call($self, $call_object);
206 }
207 sub DescribeServiceUpdates {
208 my $self = shift;
209 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeServiceUpdates', @_);
210 return $self->caller->do_call($self, $call_object);
211 }
212 sub DescribeSnapshots {
213 my $self = shift;
214 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeSnapshots', @_);
215 return $self->caller->do_call($self, $call_object);
216 }
217 sub DescribeUpdateActions {
218 my $self = shift;
219 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeUpdateActions', @_);
220 return $self->caller->do_call($self, $call_object);
221 }
222 sub DescribeUserGroups {
223 my $self = shift;
224 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeUserGroups', @_);
225 return $self->caller->do_call($self, $call_object);
226 }
227 sub DescribeUsers {
228 my $self = shift;
229 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DescribeUsers', @_);
230 return $self->caller->do_call($self, $call_object);
231 }
232 sub DisassociateGlobalReplicationGroup {
233 my $self = shift;
234 my $call_object = $self->new_with_coercions('Paws::ElastiCache::DisassociateGlobalReplicationGroup', @_);
235 return $self->caller->do_call($self, $call_object);
236 }
237 sub FailoverGlobalReplicationGroup {
238 my $self = shift;
239 my $call_object = $self->new_with_coercions('Paws::ElastiCache::FailoverGlobalReplicationGroup', @_);
240 return $self->caller->do_call($self, $call_object);
241 }
242 sub IncreaseNodeGroupsInGlobalReplicationGroup {
243 my $self = shift;
244 my $call_object = $self->new_with_coercions('Paws::ElastiCache::IncreaseNodeGroupsInGlobalReplicationGroup', @_);
245 return $self->caller->do_call($self, $call_object);
246 }
247 sub IncreaseReplicaCount {
248 my $self = shift;
249 my $call_object = $self->new_with_coercions('Paws::ElastiCache::IncreaseReplicaCount', @_);
250 return $self->caller->do_call($self, $call_object);
251 }
252 sub ListAllowedNodeTypeModifications {
253 my $self = shift;
254 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ListAllowedNodeTypeModifications', @_);
255 return $self->caller->do_call($self, $call_object);
256 }
257 sub ListTagsForResource {
258 my $self = shift;
259 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ListTagsForResource', @_);
260 return $self->caller->do_call($self, $call_object);
261 }
262 sub ModifyCacheCluster {
263 my $self = shift;
264 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyCacheCluster', @_);
265 return $self->caller->do_call($self, $call_object);
266 }
267 sub ModifyCacheParameterGroup {
268 my $self = shift;
269 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyCacheParameterGroup', @_);
270 return $self->caller->do_call($self, $call_object);
271 }
272 sub ModifyCacheSubnetGroup {
273 my $self = shift;
274 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyCacheSubnetGroup', @_);
275 return $self->caller->do_call($self, $call_object);
276 }
277 sub ModifyGlobalReplicationGroup {
278 my $self = shift;
279 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyGlobalReplicationGroup', @_);
280 return $self->caller->do_call($self, $call_object);
281 }
282 sub ModifyReplicationGroup {
283 my $self = shift;
284 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyReplicationGroup', @_);
285 return $self->caller->do_call($self, $call_object);
286 }
287 sub ModifyReplicationGroupShardConfiguration {
288 my $self = shift;
289 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyReplicationGroupShardConfiguration', @_);
290 return $self->caller->do_call($self, $call_object);
291 }
292 sub ModifyUser {
293 my $self = shift;
294 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyUser', @_);
295 return $self->caller->do_call($self, $call_object);
296 }
297 sub ModifyUserGroup {
298 my $self = shift;
299 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ModifyUserGroup', @_);
300 return $self->caller->do_call($self, $call_object);
301 }
302 sub PurchaseReservedCacheNodesOffering {
303 my $self = shift;
304 my $call_object = $self->new_with_coercions('Paws::ElastiCache::PurchaseReservedCacheNodesOffering', @_);
305 return $self->caller->do_call($self, $call_object);
306 }
307 sub RebalanceSlotsInGlobalReplicationGroup {
308 my $self = shift;
309 my $call_object = $self->new_with_coercions('Paws::ElastiCache::RebalanceSlotsInGlobalReplicationGroup', @_);
310 return $self->caller->do_call($self, $call_object);
311 }
312 sub RebootCacheCluster {
313 my $self = shift;
314 my $call_object = $self->new_with_coercions('Paws::ElastiCache::RebootCacheCluster', @_);
315 return $self->caller->do_call($self, $call_object);
316 }
317 sub RemoveTagsFromResource {
318 my $self = shift;
319 my $call_object = $self->new_with_coercions('Paws::ElastiCache::RemoveTagsFromResource', @_);
320 return $self->caller->do_call($self, $call_object);
321 }
322 sub ResetCacheParameterGroup {
323 my $self = shift;
324 my $call_object = $self->new_with_coercions('Paws::ElastiCache::ResetCacheParameterGroup', @_);
325 return $self->caller->do_call($self, $call_object);
326 }
327 sub RevokeCacheSecurityGroupIngress {
328 my $self = shift;
329 my $call_object = $self->new_with_coercions('Paws::ElastiCache::RevokeCacheSecurityGroupIngress', @_);
330 return $self->caller->do_call($self, $call_object);
331 }
332 sub StartMigration {
333 my $self = shift;
334 my $call_object = $self->new_with_coercions('Paws::ElastiCache::StartMigration', @_);
335 return $self->caller->do_call($self, $call_object);
336 }
337 sub TestFailover {
338 my $self = shift;
339 my $call_object = $self->new_with_coercions('Paws::ElastiCache::TestFailover', @_);
340 return $self->caller->do_call($self, $call_object);
341 }
342
343 sub DescribeAllCacheClusters {
344 my $self = shift;
345  
346 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
347 my $result = $self->DescribeCacheClusters(@_);
348 my $next_result = $result;
349  
350 if (not defined $callback) {
351 while ($next_result->Marker) {
352 $next_result = $self->DescribeCacheClusters(@_, Marker => $next_result->Marker);
353 push @{ $result->CacheClusters }, @{ $next_result->CacheClusters };
354 }
355 return $result;
356 } else {
357 while ($result->Marker) {
358 $callback->($_ => 'CacheClusters') foreach (@{ $result->CacheClusters });
359 $result = $self->DescribeCacheClusters(@_, Marker => $result->Marker);
360 }
361 $callback->($_ => 'CacheClusters') foreach (@{ $result->CacheClusters });
362 }
363  
364 return undef
365 }
366 sub DescribeAllCacheEngineVersions {
367 my $self = shift;
368  
369 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
370 my $result = $self->DescribeCacheEngineVersions(@_);
371 my $next_result = $result;
372  
373 if (not defined $callback) {
374 while ($next_result->Marker) {
375 $next_result = $self->DescribeCacheEngineVersions(@_, Marker => $next_result->Marker);
376 push @{ $result->CacheEngineVersions }, @{ $next_result->CacheEngineVersions };
377 }
378 return $result;
379 } else {
380 while ($result->Marker) {
381 $callback->($_ => 'CacheEngineVersions') foreach (@{ $result->CacheEngineVersions });
382 $result = $self->DescribeCacheEngineVersions(@_, Marker => $result->Marker);
383 }
384 $callback->($_ => 'CacheEngineVersions') foreach (@{ $result->CacheEngineVersions });
385 }
386  
387 return undef
388 }
389 sub DescribeAllCacheParameterGroups {
390 my $self = shift;
391  
392 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
393 my $result = $self->DescribeCacheParameterGroups(@_);
394 my $next_result = $result;
395  
396 if (not defined $callback) {
397 while ($next_result->Marker) {
398 $next_result = $self->DescribeCacheParameterGroups(@_, Marker => $next_result->Marker);
399 push @{ $result->CacheParameterGroups }, @{ $next_result->CacheParameterGroups };
400 }
401 return $result;
402 } else {
403 while ($result->Marker) {
404 $callback->($_ => 'CacheParameterGroups') foreach (@{ $result->CacheParameterGroups });
405 $result = $self->DescribeCacheParameterGroups(@_, Marker => $result->Marker);
406 }
407 $callback->($_ => 'CacheParameterGroups') foreach (@{ $result->CacheParameterGroups });
408 }
409  
410 return undef
411 }
412 sub DescribeAllCacheParameters {
413 my $self = shift;
414  
415 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
416 my $result = $self->DescribeCacheParameters(@_);
417 my $next_result = $result;
418  
419 if (not defined $callback) {
420 while ($next_result->Marker) {
421 $next_result = $self->DescribeCacheParameters(@_, Marker => $next_result->Marker);
422 push @{ $result->Parameters }, @{ $next_result->Parameters };
423 }
424 return $result;
425 } else {
426 while ($result->Marker) {
427 $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
428 $result = $self->DescribeCacheParameters(@_, Marker => $result->Marker);
429 }
430 $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
431 }
432  
433 return undef
434 }
435 sub DescribeAllCacheSecurityGroups {
436 my $self = shift;
437  
438 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
439 my $result = $self->DescribeCacheSecurityGroups(@_);
440 my $next_result = $result;
441  
442 if (not defined $callback) {
443 while ($next_result->Marker) {
444 $next_result = $self->DescribeCacheSecurityGroups(@_, Marker => $next_result->Marker);
445 push @{ $result->CacheSecurityGroups }, @{ $next_result->CacheSecurityGroups };
446 }
447 return $result;
448 } else {
449 while ($result->Marker) {
450 $callback->($_ => 'CacheSecurityGroups') foreach (@{ $result->CacheSecurityGroups });
451 $result = $self->DescribeCacheSecurityGroups(@_, Marker => $result->Marker);
452 }
453 $callback->($_ => 'CacheSecurityGroups') foreach (@{ $result->CacheSecurityGroups });
454 }
455  
456 return undef
457 }
458 sub DescribeAllCacheSubnetGroups {
459 my $self = shift;
460  
461 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
462 my $result = $self->DescribeCacheSubnetGroups(@_);
463 my $next_result = $result;
464  
465 if (not defined $callback) {
466 while ($next_result->Marker) {
467 $next_result = $self->DescribeCacheSubnetGroups(@_, Marker => $next_result->Marker);
468 push @{ $result->CacheSubnetGroups }, @{ $next_result->CacheSubnetGroups };
469 }
470 return $result;
471 } else {
472 while ($result->Marker) {
473 $callback->($_ => 'CacheSubnetGroups') foreach (@{ $result->CacheSubnetGroups });
474 $result = $self->DescribeCacheSubnetGroups(@_, Marker => $result->Marker);
475 }
476 $callback->($_ => 'CacheSubnetGroups') foreach (@{ $result->CacheSubnetGroups });
477 }
478  
479 return undef
480 }
481 sub DescribeAllEngineDefaultParameters {
482 my $self = shift;
483  
484 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
485 my $result = $self->DescribeEngineDefaultParameters(@_);
486 my $next_result = $result;
487  
488 if (not defined $callback) {
489 while ($next_result->EngineDefaults->Marker) {
490 $next_result = $self->DescribeEngineDefaultParameters(@_, Marker => $next_result->EngineDefaults->Marker);
491 push @{ $result->EngineDefaults->Parameters }, @{ $next_result->EngineDefaults->Parameters };
492 }
493 return $result;
494 } else {
495 while ($result->EngineDefaults->Marker) {
496 $callback->($_ => 'EngineDefaults.Parameters') foreach (@{ $result->EngineDefaults->Parameters });
497 $result = $self->DescribeEngineDefaultParameters(@_, Marker => $result->EngineDefaults->Marker);
498 }
499 $callback->($_ => 'EngineDefaults.Parameters') foreach (@{ $result->EngineDefaults->Parameters });
500 }
501  
502 return undef
503 }
504 sub DescribeAllEvents {
505 my $self = shift;
506  
507 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
508 my $result = $self->DescribeEvents(@_);
509 my $next_result = $result;
510  
511 if (not defined $callback) {
512 while ($next_result->Marker) {
513 $next_result = $self->DescribeEvents(@_, Marker => $next_result->Marker);
514 push @{ $result->Events }, @{ $next_result->Events };
515 }
516 return $result;
517 } else {
518 while ($result->Marker) {
519 $callback->($_ => 'Events') foreach (@{ $result->Events });
520 $result = $self->DescribeEvents(@_, Marker => $result->Marker);
521 }
522 $callback->($_ => 'Events') foreach (@{ $result->Events });
523 }
524  
525 return undef
526 }
527 sub DescribeAllGlobalReplicationGroups {
528 my $self = shift;
529  
530 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
531 my $result = $self->DescribeGlobalReplicationGroups(@_);
532 my $next_result = $result;
533  
534 if (not defined $callback) {
535 while ($next_result->Marker) {
536 $next_result = $self->DescribeGlobalReplicationGroups(@_, Marker => $next_result->Marker);
537 push @{ $result->GlobalReplicationGroups }, @{ $next_result->GlobalReplicationGroups };
538 }
539 return $result;
540 } else {
541 while ($result->Marker) {
542 $callback->($_ => 'GlobalReplicationGroups') foreach (@{ $result->GlobalReplicationGroups });
543 $result = $self->DescribeGlobalReplicationGroups(@_, Marker => $result->Marker);
544 }
545 $callback->($_ => 'GlobalReplicationGroups') foreach (@{ $result->GlobalReplicationGroups });
546 }
547  
548 return undef
549 }
550 sub DescribeAllReplicationGroups {
551 my $self = shift;
552  
553 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
554 my $result = $self->DescribeReplicationGroups(@_);
555 my $next_result = $result;
556  
557 if (not defined $callback) {
558 while ($next_result->Marker) {
559 $next_result = $self->DescribeReplicationGroups(@_, Marker => $next_result->Marker);
560 push @{ $result->ReplicationGroups }, @{ $next_result->ReplicationGroups };
561 }
562 return $result;
563 } else {
564 while ($result->Marker) {
565 $callback->($_ => 'ReplicationGroups') foreach (@{ $result->ReplicationGroups });
566 $result = $self->DescribeReplicationGroups(@_, Marker => $result->Marker);
567 }
568 $callback->($_ => 'ReplicationGroups') foreach (@{ $result->ReplicationGroups });
569 }
570  
571 return undef
572 }
573 sub DescribeAllReservedCacheNodes {
574 my $self = shift;
575  
576 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
577 my $result = $self->DescribeReservedCacheNodes(@_);
578 my $next_result = $result;
579  
580 if (not defined $callback) {
581 while ($next_result->Marker) {
582 $next_result = $self->DescribeReservedCacheNodes(@_, Marker => $next_result->Marker);
583 push @{ $result->ReservedCacheNodes }, @{ $next_result->ReservedCacheNodes };
584 }
585 return $result;
586 } else {
587 while ($result->Marker) {
588 $callback->($_ => 'ReservedCacheNodes') foreach (@{ $result->ReservedCacheNodes });
589 $result = $self->DescribeReservedCacheNodes(@_, Marker => $result->Marker);
590 }
591 $callback->($_ => 'ReservedCacheNodes') foreach (@{ $result->ReservedCacheNodes });
592 }
593  
594 return undef
595 }
596 sub DescribeAllReservedCacheNodesOfferings {
597 my $self = shift;
598  
599 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
600 my $result = $self->DescribeReservedCacheNodesOfferings(@_);
601 my $next_result = $result;
602  
603 if (not defined $callback) {
604 while ($next_result->Marker) {
605 $next_result = $self->DescribeReservedCacheNodesOfferings(@_, Marker => $next_result->Marker);
606 push @{ $result->ReservedCacheNodesOfferings }, @{ $next_result->ReservedCacheNodesOfferings };
607 }
608 return $result;
609 } else {
610 while ($result->Marker) {
611 $callback->($_ => 'ReservedCacheNodesOfferings') foreach (@{ $result->ReservedCacheNodesOfferings });
612 $result = $self->DescribeReservedCacheNodesOfferings(@_, Marker => $result->Marker);
613 }
614 $callback->($_ => 'ReservedCacheNodesOfferings') foreach (@{ $result->ReservedCacheNodesOfferings });
615 }
616  
617 return undef
618 }
619 sub DescribeAllServiceUpdates {
620 my $self = shift;
621  
622 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
623 my $result = $self->DescribeServiceUpdates(@_);
624 my $next_result = $result;
625  
626 if (not defined $callback) {
627 while ($next_result->Marker) {
628 $next_result = $self->DescribeServiceUpdates(@_, Marker => $next_result->Marker);
629 push @{ $result->ServiceUpdates }, @{ $next_result->ServiceUpdates };
630 }
631 return $result;
632 } else {
633 while ($result->Marker) {
634 $callback->($_ => 'ServiceUpdates') foreach (@{ $result->ServiceUpdates });
635 $result = $self->DescribeServiceUpdates(@_, Marker => $result->Marker);
636 }
637 $callback->($_ => 'ServiceUpdates') foreach (@{ $result->ServiceUpdates });
638 }
639  
640 return undef
641 }
642 sub DescribeAllSnapshots {
643 my $self = shift;
644  
645 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
646 my $result = $self->DescribeSnapshots(@_);
647 my $next_result = $result;
648  
649 if (not defined $callback) {
650 while ($next_result->Marker) {
651 $next_result = $self->DescribeSnapshots(@_, Marker => $next_result->Marker);
652 push @{ $result->Snapshots }, @{ $next_result->Snapshots };
653 }
654 return $result;
655 } else {
656 while ($result->Marker) {
657 $callback->($_ => 'Snapshots') foreach (@{ $result->Snapshots });
658 $result = $self->DescribeSnapshots(@_, Marker => $result->Marker);
659 }
660 $callback->($_ => 'Snapshots') foreach (@{ $result->Snapshots });
661 }
662  
663 return undef
664 }
665 sub DescribeAllUpdateActions {
666 my $self = shift;
667  
668 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
669 my $result = $self->DescribeUpdateActions(@_);
670 my $next_result = $result;
671  
672 if (not defined $callback) {
673 while ($next_result->Marker) {
674 $next_result = $self->DescribeUpdateActions(@_, Marker => $next_result->Marker);
675 push @{ $result->UpdateActions }, @{ $next_result->UpdateActions };
676 }
677 return $result;
678 } else {
679 while ($result->Marker) {
680 $callback->($_ => 'UpdateActions') foreach (@{ $result->UpdateActions });
681 $result = $self->DescribeUpdateActions(@_, Marker => $result->Marker);
682 }
683 $callback->($_ => 'UpdateActions') foreach (@{ $result->UpdateActions });
684 }
685  
686 return undef
687 }
688 sub DescribeAllUserGroups {
689 my $self = shift;
690  
691 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
692 my $result = $self->DescribeUserGroups(@_);
693 my $next_result = $result;
694  
695 if (not defined $callback) {
696 while ($next_result->Marker) {
697 $next_result = $self->DescribeUserGroups(@_, Marker => $next_result->Marker);
698 push @{ $result->UserGroups }, @{ $next_result->UserGroups };
699 }
700 return $result;
701 } else {
702 while ($result->Marker) {
703 $callback->($_ => 'UserGroups') foreach (@{ $result->UserGroups });
704 $result = $self->DescribeUserGroups(@_, Marker => $result->Marker);
705 }
706 $callback->($_ => 'UserGroups') foreach (@{ $result->UserGroups });
707 }
708  
709 return undef
710 }
711 sub DescribeAllUsers {
712 my $self = shift;
713  
714 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
715 my $result = $self->DescribeUsers(@_);
716 my $next_result = $result;
717  
718 if (not defined $callback) {
719 while ($next_result->Marker) {
720 $next_result = $self->DescribeUsers(@_, Marker => $next_result->Marker);
721 push @{ $result->Users }, @{ $next_result->Users };
722 }
723 return $result;
724 } else {
725 while ($result->Marker) {
726 $callback->($_ => 'Users') foreach (@{ $result->Users });
727 $result = $self->DescribeUsers(@_, Marker => $result->Marker);
728 }
729 $callback->($_ => 'Users') foreach (@{ $result->Users });
730 }
731  
732 return undef
733 }
734  
735  
736 sub operations { qw/AddTagsToResource AuthorizeCacheSecurityGroupIngress BatchApplyUpdateAction BatchStopUpdateAction CompleteMigration CopySnapshot CreateCacheCluster CreateCacheParameterGroup CreateCacheSecurityGroup CreateCacheSubnetGroup CreateGlobalReplicationGroup CreateReplicationGroup CreateSnapshot CreateUser CreateUserGroup DecreaseNodeGroupsInGlobalReplicationGroup DecreaseReplicaCount DeleteCacheCluster DeleteCacheParameterGroup DeleteCacheSecurityGroup DeleteCacheSubnetGroup DeleteGlobalReplicationGroup DeleteReplicationGroup DeleteSnapshot DeleteUser DeleteUserGroup DescribeCacheClusters DescribeCacheEngineVersions DescribeCacheParameterGroups DescribeCacheParameters DescribeCacheSecurityGroups DescribeCacheSubnetGroups DescribeEngineDefaultParameters DescribeEvents DescribeGlobalReplicationGroups DescribeReplicationGroups DescribeReservedCacheNodes DescribeReservedCacheNodesOfferings DescribeServiceUpdates DescribeSnapshots DescribeUpdateActions DescribeUserGroups DescribeUsers DisassociateGlobalReplicationGroup FailoverGlobalReplicationGroup IncreaseNodeGroupsInGlobalReplicationGroup IncreaseReplicaCount ListAllowedNodeTypeModifications ListTagsForResource ModifyCacheCluster ModifyCacheParameterGroup ModifyCacheSubnetGroup ModifyGlobalReplicationGroup ModifyReplicationGroup ModifyReplicationGroupShardConfiguration ModifyUser ModifyUserGroup PurchaseReservedCacheNodesOffering RebalanceSlotsInGlobalReplicationGroup RebootCacheCluster RemoveTagsFromResource ResetCacheParameterGroup RevokeCacheSecurityGroupIngress StartMigration TestFailover / }
737  
738 1;
739  
740 ### main pod documentation begin ###
741  
742 =head1 NAME
743  
744 Paws::ElastiCache - Perl Interface to AWS Amazon ElastiCache
745  
746 =head1 SYNOPSIS
747  
748 use Paws;
749  
750 my $obj = Paws->service('ElastiCache');
751 my $res = $obj->Method(
752 Arg1 => $val1,
753 Arg2 => [ 'V1', 'V2' ],
754 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
755 # of the arguments type
756 Arg3 => { Att1 => 'Val1' },
757 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
758 # the constructor of the arguments type
759 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
760 );
761  
762 =head1 DESCRIPTION
763  
764 Amazon ElastiCache
765  
766 Amazon ElastiCache is a web service that makes it easier to set up,
767 operate, and scale a distributed cache in the cloud.
768  
769 With ElastiCache, customers get all of the benefits of a
770 high-performance, in-memory cache with less of the administrative
771 burden involved in launching and managing a distributed cache. The
772 service makes setup, scaling, and cluster failure handling much simpler
773 than in a self-managed cache deployment.
774  
775 In addition, through integration with Amazon CloudWatch, customers get
776 enhanced visibility into the key performance statistics associated with
777 their cache and can receive alarms if a part of their cache runs hot.
778  
779 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/elasticache-2015-02-02>
780  
781  
782 =head1 METHODS
783  
784 =head2 AddTagsToResource
785  
786 =over
787  
788 =item ResourceName => Str
789  
790 =item Tags => ArrayRef[L<Paws::ElastiCache::Tag>]
791  
792  
793 =back
794  
795 Each argument is described in detail in: L<Paws::ElastiCache::AddTagsToResource>
796  
797 Returns: a L<Paws::ElastiCache::TagListMessage> instance
798  
799 A tag is a key-value pair where the key and value are case-sensitive.
800 You can use tags to categorize and track all your ElastiCache
801 resources, with the exception of global replication group. When you add
802 or remove tags on replication groups, those actions will be replicated
803 to all nodes in the replication group. For more information, see
804 Resource-level permissions
805 (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/IAM.ResourceLevelPermissions.html).
806  
807 For example, you can use cost-allocation tags to your ElastiCache
808 resources, AWS generates a cost allocation report as a comma-separated
809 value (CSV) file with your usage and costs aggregated by your tags. You
810 can apply tags that represent business categories (such as cost
811 centers, application names, or owners) to organize your costs across
812 multiple services.
813  
814 For more information, see Using Cost Allocation Tags in Amazon
815 ElastiCache
816 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Tagging.html)
817 in the I<ElastiCache User Guide>.
818  
819  
820 =head2 AuthorizeCacheSecurityGroupIngress
821  
822 =over
823  
824 =item CacheSecurityGroupName => Str
825  
826 =item EC2SecurityGroupName => Str
827  
828 =item EC2SecurityGroupOwnerId => Str
829  
830  
831 =back
832  
833 Each argument is described in detail in: L<Paws::ElastiCache::AuthorizeCacheSecurityGroupIngress>
834  
835 Returns: a L<Paws::ElastiCache::AuthorizeCacheSecurityGroupIngressResult> instance
836  
837 Allows network ingress to a cache security group. Applications using
838 ElastiCache must be running on Amazon EC2, and Amazon EC2 security
839 groups are used as the authorization mechanism.
840  
841 You cannot authorize ingress from an Amazon EC2 security group in one
842 region to an ElastiCache cluster in another region.
843  
844  
845 =head2 BatchApplyUpdateAction
846  
847 =over
848  
849 =item ServiceUpdateName => Str
850  
851 =item [CacheClusterIds => ArrayRef[Str|Undef]]
852  
853 =item [ReplicationGroupIds => ArrayRef[Str|Undef]]
854  
855  
856 =back
857  
858 Each argument is described in detail in: L<Paws::ElastiCache::BatchApplyUpdateAction>
859  
860 Returns: a L<Paws::ElastiCache::UpdateActionResultsMessage> instance
861  
862 Apply the service update. For more information on service updates and
863 applying them, see Applying Service Updates
864 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/applying-updates.html).
865  
866  
867 =head2 BatchStopUpdateAction
868  
869 =over
870  
871 =item ServiceUpdateName => Str
872  
873 =item [CacheClusterIds => ArrayRef[Str|Undef]]
874  
875 =item [ReplicationGroupIds => ArrayRef[Str|Undef]]
876  
877  
878 =back
879  
880 Each argument is described in detail in: L<Paws::ElastiCache::BatchStopUpdateAction>
881  
882 Returns: a L<Paws::ElastiCache::UpdateActionResultsMessage> instance
883  
884 Stop the service update. For more information on service updates and
885 stopping them, see Stopping Service Updates
886 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/stopping-self-service-updates.html).
887  
888  
889 =head2 CompleteMigration
890  
891 =over
892  
893 =item ReplicationGroupId => Str
894  
895 =item [Force => Bool]
896  
897  
898 =back
899  
900 Each argument is described in detail in: L<Paws::ElastiCache::CompleteMigration>
901  
902 Returns: a L<Paws::ElastiCache::CompleteMigrationResponse> instance
903  
904 Complete the migration of data.
905  
906  
907 =head2 CopySnapshot
908  
909 =over
910  
911 =item SourceSnapshotName => Str
912  
913 =item TargetSnapshotName => Str
914  
915 =item [KmsKeyId => Str]
916  
917 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
918  
919 =item [TargetBucket => Str]
920  
921  
922 =back
923  
924 Each argument is described in detail in: L<Paws::ElastiCache::CopySnapshot>
925  
926 Returns: a L<Paws::ElastiCache::CopySnapshotResult> instance
927  
928 Makes a copy of an existing snapshot.
929  
930 This operation is valid for Redis only.
931  
932 Users or groups that have permissions to use the C<CopySnapshot>
933 operation can create their own Amazon S3 buckets and copy snapshots to
934 it. To control access to your snapshots, use an IAM policy to control
935 who has the ability to use the C<CopySnapshot> operation. For more
936 information about using IAM to control the use of ElastiCache
937 operations, see Exporting Snapshots
938 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-exporting.html)
939 and Authentication & Access Control
940 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/IAM.html).
941  
942 You could receive the following error messages.
943  
944 B<Error Messages>
945  
946 =over
947  
948 =item *
949  
950 B<Error Message:> The S3 bucket %s is outside of the region.
951  
952 B<Solution:> Create an Amazon S3 bucket in the same region as your
953 snapshot. For more information, see Step 1: Create an Amazon S3 Bucket
954 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-exporting.html#backups-exporting-create-s3-bucket)
955 in the ElastiCache User Guide.
956  
957 =item *
958  
959 B<Error Message:> The S3 bucket %s does not exist.
960  
961 B<Solution:> Create an Amazon S3 bucket in the same region as your
962 snapshot. For more information, see Step 1: Create an Amazon S3 Bucket
963 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-exporting.html#backups-exporting-create-s3-bucket)
964 in the ElastiCache User Guide.
965  
966 =item *
967  
968 B<Error Message:> The S3 bucket %s is not owned by the authenticated
969 user.
970  
971 B<Solution:> Create an Amazon S3 bucket in the same region as your
972 snapshot. For more information, see Step 1: Create an Amazon S3 Bucket
973 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-exporting.html#backups-exporting-create-s3-bucket)
974 in the ElastiCache User Guide.
975  
976 =item *
977  
978 B<Error Message:> The authenticated user does not have sufficient
979 permissions to perform the desired activity.
980  
981 B<Solution:> Contact your system administrator to get the needed
982 permissions.
983  
984 =item *
985  
986 B<Error Message:> The S3 bucket %s already contains an object with key
987 %s.
988  
989 B<Solution:> Give the C<TargetSnapshotName> a new and unique value. If
990 exporting a snapshot, you could alternatively create a new Amazon S3
991 bucket and use this same value for C<TargetSnapshotName>.
992  
993 =item *
994  
995 B<Error Message: > ElastiCache has not been granted READ permissions %s
996 on the S3 Bucket.
997  
998 B<Solution:> Add List and Read permissions on the bucket. For more
999 information, see Step 2: Grant ElastiCache Access to Your Amazon S3
1000 Bucket
1001 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-exporting.html#backups-exporting-grant-access)
1002 in the ElastiCache User Guide.
1003  
1004 =item *
1005  
1006 B<Error Message: > ElastiCache has not been granted WRITE permissions
1007 %s on the S3 Bucket.
1008  
1009 B<Solution:> Add Upload/Delete permissions on the bucket. For more
1010 information, see Step 2: Grant ElastiCache Access to Your Amazon S3
1011 Bucket
1012 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-exporting.html#backups-exporting-grant-access)
1013 in the ElastiCache User Guide.
1014  
1015 =item *
1016  
1017 B<Error Message: > ElastiCache has not been granted READ_ACP
1018 permissions %s on the S3 Bucket.
1019  
1020 B<Solution:> Add View Permissions on the bucket. For more information,
1021 see Step 2: Grant ElastiCache Access to Your Amazon S3 Bucket
1022 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-exporting.html#backups-exporting-grant-access)
1023 in the ElastiCache User Guide.
1024  
1025 =back
1026  
1027  
1028  
1029 =head2 CreateCacheCluster
1030  
1031 =over
1032  
1033 =item CacheClusterId => Str
1034  
1035 =item [AuthToken => Str]
1036  
1037 =item [AutoMinorVersionUpgrade => Bool]
1038  
1039 =item [AZMode => Str]
1040  
1041 =item [CacheNodeType => Str]
1042  
1043 =item [CacheParameterGroupName => Str]
1044  
1045 =item [CacheSecurityGroupNames => ArrayRef[Str|Undef]]
1046  
1047 =item [CacheSubnetGroupName => Str]
1048  
1049 =item [Engine => Str]
1050  
1051 =item [EngineVersion => Str]
1052  
1053 =item [LogDeliveryConfigurations => ArrayRef[L<Paws::ElastiCache::LogDeliveryConfigurationRequest>]]
1054  
1055 =item [NotificationTopicArn => Str]
1056  
1057 =item [NumCacheNodes => Int]
1058  
1059 =item [OutpostMode => Str]
1060  
1061 =item [Port => Int]
1062  
1063 =item [PreferredAvailabilityZone => Str]
1064  
1065 =item [PreferredAvailabilityZones => ArrayRef[Str|Undef]]
1066  
1067 =item [PreferredMaintenanceWindow => Str]
1068  
1069 =item [PreferredOutpostArn => Str]
1070  
1071 =item [PreferredOutpostArns => ArrayRef[Str|Undef]]
1072  
1073 =item [ReplicationGroupId => Str]
1074  
1075 =item [SecurityGroupIds => ArrayRef[Str|Undef]]
1076  
1077 =item [SnapshotArns => ArrayRef[Str|Undef]]
1078  
1079 =item [SnapshotName => Str]
1080  
1081 =item [SnapshotRetentionLimit => Int]
1082  
1083 =item [SnapshotWindow => Str]
1084  
1085 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
1086  
1087  
1088 =back
1089  
1090 Each argument is described in detail in: L<Paws::ElastiCache::CreateCacheCluster>
1091  
1092 Returns: a L<Paws::ElastiCache::CreateCacheClusterResult> instance
1093  
1094 Creates a cluster. All nodes in the cluster run the same
1095 protocol-compliant cache engine software, either Memcached or Redis.
1096  
1097 This operation is not supported for Redis (cluster mode enabled)
1098 clusters.
1099  
1100  
1101 =head2 CreateCacheParameterGroup
1102  
1103 =over
1104  
1105 =item CacheParameterGroupFamily => Str
1106  
1107 =item CacheParameterGroupName => Str
1108  
1109 =item Description => Str
1110  
1111 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
1112  
1113  
1114 =back
1115  
1116 Each argument is described in detail in: L<Paws::ElastiCache::CreateCacheParameterGroup>
1117  
1118 Returns: a L<Paws::ElastiCache::CreateCacheParameterGroupResult> instance
1119  
1120 Creates a new Amazon ElastiCache cache parameter group. An ElastiCache
1121 cache parameter group is a collection of parameters and their values
1122 that are applied to all of the nodes in any cluster or replication
1123 group using the CacheParameterGroup.
1124  
1125 A newly created CacheParameterGroup is an exact duplicate of the
1126 default parameter group for the CacheParameterGroupFamily. To customize
1127 the newly created CacheParameterGroup you can change the values of
1128 specific parameters. For more information, see:
1129  
1130 =over
1131  
1132 =item *
1133  
1134 ModifyCacheParameterGroup
1135 (https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheParameterGroup.html)
1136 in the ElastiCache API Reference.
1137  
1138 =item *
1139  
1140 Parameters and Parameter Groups
1141 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/ParameterGroups.html)
1142 in the ElastiCache User Guide.
1143  
1144 =back
1145  
1146  
1147  
1148 =head2 CreateCacheSecurityGroup
1149  
1150 =over
1151  
1152 =item CacheSecurityGroupName => Str
1153  
1154 =item Description => Str
1155  
1156 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
1157  
1158  
1159 =back
1160  
1161 Each argument is described in detail in: L<Paws::ElastiCache::CreateCacheSecurityGroup>
1162  
1163 Returns: a L<Paws::ElastiCache::CreateCacheSecurityGroupResult> instance
1164  
1165 Creates a new cache security group. Use a cache security group to
1166 control access to one or more clusters.
1167  
1168 Cache security groups are only used when you are creating a cluster
1169 outside of an Amazon Virtual Private Cloud (Amazon VPC). If you are
1170 creating a cluster inside of a VPC, use a cache subnet group instead.
1171 For more information, see CreateCacheSubnetGroup
1172 (https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheSubnetGroup.html).
1173  
1174  
1175 =head2 CreateCacheSubnetGroup
1176  
1177 =over
1178  
1179 =item CacheSubnetGroupDescription => Str
1180  
1181 =item CacheSubnetGroupName => Str
1182  
1183 =item SubnetIds => ArrayRef[Str|Undef]
1184  
1185 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
1186  
1187  
1188 =back
1189  
1190 Each argument is described in detail in: L<Paws::ElastiCache::CreateCacheSubnetGroup>
1191  
1192 Returns: a L<Paws::ElastiCache::CreateCacheSubnetGroupResult> instance
1193  
1194 Creates a new cache subnet group.
1195  
1196 Use this parameter only when you are creating a cluster in an Amazon
1197 Virtual Private Cloud (Amazon VPC).
1198  
1199  
1200 =head2 CreateGlobalReplicationGroup
1201  
1202 =over
1203  
1204 =item GlobalReplicationGroupIdSuffix => Str
1205  
1206 =item PrimaryReplicationGroupId => Str
1207  
1208 =item [GlobalReplicationGroupDescription => Str]
1209  
1210  
1211 =back
1212  
1213 Each argument is described in detail in: L<Paws::ElastiCache::CreateGlobalReplicationGroup>
1214  
1215 Returns: a L<Paws::ElastiCache::CreateGlobalReplicationGroupResult> instance
1216  
1217 Global Datastore for Redis offers fully managed, fast, reliable and
1218 secure cross-region replication. Using Global Datastore for Redis, you
1219 can create cross-region read replica clusters for ElastiCache for Redis
1220 to enable low-latency reads and disaster recovery across regions. For
1221 more information, see Replication Across Regions Using Global Datastore
1222 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastore.html).
1223  
1224 =over
1225  
1226 =item *
1227  
1228 The B<GlobalReplicationGroupIdSuffix> is the name of the Global
1229 datastore.
1230  
1231 =item *
1232  
1233 The B<PrimaryReplicationGroupId> represents the name of the primary
1234 cluster that accepts writes and will replicate updates to the secondary
1235 cluster.
1236  
1237 =back
1238  
1239  
1240  
1241 =head2 CreateReplicationGroup
1242  
1243 =over
1244  
1245 =item ReplicationGroupDescription => Str
1246  
1247 =item ReplicationGroupId => Str
1248  
1249 =item [AtRestEncryptionEnabled => Bool]
1250  
1251 =item [AuthToken => Str]
1252  
1253 =item [AutomaticFailoverEnabled => Bool]
1254  
1255 =item [AutoMinorVersionUpgrade => Bool]
1256  
1257 =item [CacheNodeType => Str]
1258  
1259 =item [CacheParameterGroupName => Str]
1260  
1261 =item [CacheSecurityGroupNames => ArrayRef[Str|Undef]]
1262  
1263 =item [CacheSubnetGroupName => Str]
1264  
1265 =item [Engine => Str]
1266  
1267 =item [EngineVersion => Str]
1268  
1269 =item [GlobalReplicationGroupId => Str]
1270  
1271 =item [KmsKeyId => Str]
1272  
1273 =item [LogDeliveryConfigurations => ArrayRef[L<Paws::ElastiCache::LogDeliveryConfigurationRequest>]]
1274  
1275 =item [MultiAZEnabled => Bool]
1276  
1277 =item [NodeGroupConfiguration => ArrayRef[L<Paws::ElastiCache::NodeGroupConfiguration>]]
1278  
1279 =item [NotificationTopicArn => Str]
1280  
1281 =item [NumCacheClusters => Int]
1282  
1283 =item [NumNodeGroups => Int]
1284  
1285 =item [Port => Int]
1286  
1287 =item [PreferredCacheClusterAZs => ArrayRef[Str|Undef]]
1288  
1289 =item [PreferredMaintenanceWindow => Str]
1290  
1291 =item [PrimaryClusterId => Str]
1292  
1293 =item [ReplicasPerNodeGroup => Int]
1294  
1295 =item [SecurityGroupIds => ArrayRef[Str|Undef]]
1296  
1297 =item [SnapshotArns => ArrayRef[Str|Undef]]
1298  
1299 =item [SnapshotName => Str]
1300  
1301 =item [SnapshotRetentionLimit => Int]
1302  
1303 =item [SnapshotWindow => Str]
1304  
1305 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
1306  
1307 =item [TransitEncryptionEnabled => Bool]
1308  
1309 =item [UserGroupIds => ArrayRef[Str|Undef]]
1310  
1311  
1312 =back
1313  
1314 Each argument is described in detail in: L<Paws::ElastiCache::CreateReplicationGroup>
1315  
1316 Returns: a L<Paws::ElastiCache::CreateReplicationGroupResult> instance
1317  
1318 Creates a Redis (cluster mode disabled) or a Redis (cluster mode
1319 enabled) replication group.
1320  
1321 This API can be used to create a standalone regional replication group
1322 or a secondary replication group associated with a Global datastore.
1323  
1324 A Redis (cluster mode disabled) replication group is a collection of
1325 clusters, where one of the clusters is a read/write primary and the
1326 others are read-only replicas. Writes to the primary are asynchronously
1327 propagated to the replicas.
1328  
1329 A Redis cluster-mode enabled cluster is comprised of from 1 to 90
1330 shards (API/CLI: node groups). Each shard has a primary node and up to
1331 5 read-only replica nodes. The configuration can range from 90 shards
1332 and 0 replicas to 15 shards and 5 replicas, which is the maximum number
1333 or replicas allowed.
1334  
1335 The node or shard limit can be increased to a maximum of 500 per
1336 cluster if the Redis engine version is 5.0.6 or higher. For example,
1337 you can choose to configure a 500 node cluster that ranges between 83
1338 shards (one primary and 5 replicas per shard) and 500 shards (single
1339 primary and no replicas). Make sure there are enough available IP
1340 addresses to accommodate the increase. Common pitfalls include the
1341 subnets in the subnet group have too small a CIDR range or the subnets
1342 are shared and heavily used by other clusters. For more information,
1343 see Creating a Subnet Group
1344 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SubnetGroups.Creating.html).
1345 For versions below 5.0.6, the limit is 250 per cluster.
1346  
1347 To request a limit increase, see AWS Service Limits
1348 (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html)
1349 and choose the limit type B<Nodes per cluster per instance type>.
1350  
1351 When a Redis (cluster mode disabled) replication group has been
1352 successfully created, you can add one or more read replicas to it, up
1353 to a total of 5 read replicas. If you need to increase or decrease the
1354 number of node groups (console: shards), you can avail yourself of
1355 ElastiCache for Redis' scaling. For more information, see Scaling
1356 ElastiCache for Redis Clusters
1357 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Scaling.html)
1358 in the I<ElastiCache User Guide>.
1359  
1360 This operation is valid for Redis only.
1361  
1362  
1363 =head2 CreateSnapshot
1364  
1365 =over
1366  
1367 =item SnapshotName => Str
1368  
1369 =item [CacheClusterId => Str]
1370  
1371 =item [KmsKeyId => Str]
1372  
1373 =item [ReplicationGroupId => Str]
1374  
1375 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
1376  
1377  
1378 =back
1379  
1380 Each argument is described in detail in: L<Paws::ElastiCache::CreateSnapshot>
1381  
1382 Returns: a L<Paws::ElastiCache::CreateSnapshotResult> instance
1383  
1384 Creates a copy of an entire cluster or replication group at a specific
1385 moment in time.
1386  
1387 This operation is valid for Redis only.
1388  
1389  
1390 =head2 CreateUser
1391  
1392 =over
1393  
1394 =item AccessString => Str
1395  
1396 =item Engine => Str
1397  
1398 =item UserId => Str
1399  
1400 =item UserName => Str
1401  
1402 =item [NoPasswordRequired => Bool]
1403  
1404 =item [Passwords => ArrayRef[Str|Undef]]
1405  
1406 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
1407  
1408  
1409 =back
1410  
1411 Each argument is described in detail in: L<Paws::ElastiCache::CreateUser>
1412  
1413 Returns: a L<Paws::ElastiCache::User> instance
1414  
1415 For Redis engine version 6.x onwards: Creates a Redis user. For more
1416 information, see Using Role Based Access Control (RBAC)
1417 (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.RBAC.html).
1418  
1419  
1420 =head2 CreateUserGroup
1421  
1422 =over
1423  
1424 =item Engine => Str
1425  
1426 =item UserGroupId => Str
1427  
1428 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
1429  
1430 =item [UserIds => ArrayRef[Str|Undef]]
1431  
1432  
1433 =back
1434  
1435 Each argument is described in detail in: L<Paws::ElastiCache::CreateUserGroup>
1436  
1437 Returns: a L<Paws::ElastiCache::UserGroup> instance
1438  
1439 For Redis engine version 6.x onwards: Creates a Redis user group. For
1440 more information, see Using Role Based Access Control (RBAC)
1441 (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.RBAC.html)
1442  
1443  
1444 =head2 DecreaseNodeGroupsInGlobalReplicationGroup
1445  
1446 =over
1447  
1448 =item ApplyImmediately => Bool
1449  
1450 =item GlobalReplicationGroupId => Str
1451  
1452 =item NodeGroupCount => Int
1453  
1454 =item [GlobalNodeGroupsToRemove => ArrayRef[Str|Undef]]
1455  
1456 =item [GlobalNodeGroupsToRetain => ArrayRef[Str|Undef]]
1457  
1458  
1459 =back
1460  
1461 Each argument is described in detail in: L<Paws::ElastiCache::DecreaseNodeGroupsInGlobalReplicationGroup>
1462  
1463 Returns: a L<Paws::ElastiCache::DecreaseNodeGroupsInGlobalReplicationGroupResult> instance
1464  
1465 Decreases the number of node groups in a Global datastore
1466  
1467  
1468 =head2 DecreaseReplicaCount
1469  
1470 =over
1471  
1472 =item ApplyImmediately => Bool
1473  
1474 =item ReplicationGroupId => Str
1475  
1476 =item [NewReplicaCount => Int]
1477  
1478 =item [ReplicaConfiguration => ArrayRef[L<Paws::ElastiCache::ConfigureShard>]]
1479  
1480 =item [ReplicasToRemove => ArrayRef[Str|Undef]]
1481  
1482  
1483 =back
1484  
1485 Each argument is described in detail in: L<Paws::ElastiCache::DecreaseReplicaCount>
1486  
1487 Returns: a L<Paws::ElastiCache::DecreaseReplicaCountResult> instance
1488  
1489 Dynamically decreases the number of replicas in a Redis (cluster mode
1490 disabled) replication group or the number of replica nodes in one or
1491 more node groups (shards) of a Redis (cluster mode enabled) replication
1492 group. This operation is performed with no cluster down time.
1493  
1494  
1495 =head2 DeleteCacheCluster
1496  
1497 =over
1498  
1499 =item CacheClusterId => Str
1500  
1501 =item [FinalSnapshotIdentifier => Str]
1502  
1503  
1504 =back
1505  
1506 Each argument is described in detail in: L<Paws::ElastiCache::DeleteCacheCluster>
1507  
1508 Returns: a L<Paws::ElastiCache::DeleteCacheClusterResult> instance
1509  
1510 Deletes a previously provisioned cluster. C<DeleteCacheCluster> deletes
1511 all associated cache nodes, node endpoints and the cluster itself. When
1512 you receive a successful response from this operation, Amazon
1513 ElastiCache immediately begins deleting the cluster; you cannot cancel
1514 or revert this operation.
1515  
1516 This operation is not valid for:
1517  
1518 =over
1519  
1520 =item *
1521  
1522 Redis (cluster mode enabled) clusters
1523  
1524 =item *
1525  
1526 Redis (cluster mode disabled) clusters
1527  
1528 =item *
1529  
1530 A cluster that is the last read replica of a replication group
1531  
1532 =item *
1533  
1534 A cluster that is the primary node of a replication group
1535  
1536 =item *
1537  
1538 A node group (shard) that has Multi-AZ mode enabled
1539  
1540 =item *
1541  
1542 A cluster from a Redis (cluster mode enabled) replication group
1543  
1544 =item *
1545  
1546 A cluster that is not in the C<available> state
1547  
1548 =back
1549  
1550  
1551  
1552 =head2 DeleteCacheParameterGroup
1553  
1554 =over
1555  
1556 =item CacheParameterGroupName => Str
1557  
1558  
1559 =back
1560  
1561 Each argument is described in detail in: L<Paws::ElastiCache::DeleteCacheParameterGroup>
1562  
1563 Returns: nothing
1564  
1565 Deletes the specified cache parameter group. You cannot delete a cache
1566 parameter group if it is associated with any cache clusters. You cannot
1567 delete the default cache parameter groups in your account.
1568  
1569  
1570 =head2 DeleteCacheSecurityGroup
1571  
1572 =over
1573  
1574 =item CacheSecurityGroupName => Str
1575  
1576  
1577 =back
1578  
1579 Each argument is described in detail in: L<Paws::ElastiCache::DeleteCacheSecurityGroup>
1580  
1581 Returns: nothing
1582  
1583 Deletes a cache security group.
1584  
1585 You cannot delete a cache security group if it is associated with any
1586 clusters.
1587  
1588  
1589 =head2 DeleteCacheSubnetGroup
1590  
1591 =over
1592  
1593 =item CacheSubnetGroupName => Str
1594  
1595  
1596 =back
1597  
1598 Each argument is described in detail in: L<Paws::ElastiCache::DeleteCacheSubnetGroup>
1599  
1600 Returns: nothing
1601  
1602 Deletes a cache subnet group.
1603  
1604 You cannot delete a default cache subnet group or one that is
1605 associated with any clusters.
1606  
1607  
1608 =head2 DeleteGlobalReplicationGroup
1609  
1610 =over
1611  
1612 =item GlobalReplicationGroupId => Str
1613  
1614 =item RetainPrimaryReplicationGroup => Bool
1615  
1616  
1617 =back
1618  
1619 Each argument is described in detail in: L<Paws::ElastiCache::DeleteGlobalReplicationGroup>
1620  
1621 Returns: a L<Paws::ElastiCache::DeleteGlobalReplicationGroupResult> instance
1622  
1623 Deleting a Global datastore is a two-step process:
1624  
1625 =over
1626  
1627 =item *
1628  
1629 First, you must DisassociateGlobalReplicationGroup to remove the
1630 secondary clusters in the Global datastore.
1631  
1632 =item *
1633  
1634 Once the Global datastore contains only the primary cluster, you can
1635 use the C<DeleteGlobalReplicationGroup> API to delete the Global
1636 datastore while retainining the primary cluster using
1637 C<RetainPrimaryReplicationGroup=true>.
1638  
1639 =back
1640  
1641 Since the Global Datastore has only a primary cluster, you can delete
1642 the Global Datastore while retaining the primary by setting
1643 C<RetainPrimaryReplicationGroup=true>. The primary cluster is never
1644 deleted when deleting a Global Datastore. It can only be deleted when
1645 it no longer is associated with any Global Datastore.
1646  
1647 When you receive a successful response from this operation, Amazon
1648 ElastiCache immediately begins deleting the selected resources; you
1649 cannot cancel or revert this operation.
1650  
1651  
1652 =head2 DeleteReplicationGroup
1653  
1654 =over
1655  
1656 =item ReplicationGroupId => Str
1657  
1658 =item [FinalSnapshotIdentifier => Str]
1659  
1660 =item [RetainPrimaryCluster => Bool]
1661  
1662  
1663 =back
1664  
1665 Each argument is described in detail in: L<Paws::ElastiCache::DeleteReplicationGroup>
1666  
1667 Returns: a L<Paws::ElastiCache::DeleteReplicationGroupResult> instance
1668  
1669 Deletes an existing replication group. By default, this operation
1670 deletes the entire replication group, including the primary/primaries
1671 and all of the read replicas. If the replication group has only one
1672 primary, you can optionally delete only the read replicas, while
1673 retaining the primary by setting C<RetainPrimaryCluster=true>.
1674  
1675 When you receive a successful response from this operation, Amazon
1676 ElastiCache immediately begins deleting the selected resources; you
1677 cannot cancel or revert this operation.
1678  
1679 This operation is valid for Redis only.
1680  
1681  
1682 =head2 DeleteSnapshot
1683  
1684 =over
1685  
1686 =item SnapshotName => Str
1687  
1688  
1689 =back
1690  
1691 Each argument is described in detail in: L<Paws::ElastiCache::DeleteSnapshot>
1692  
1693 Returns: a L<Paws::ElastiCache::DeleteSnapshotResult> instance
1694  
1695 Deletes an existing snapshot. When you receive a successful response
1696 from this operation, ElastiCache immediately begins deleting the
1697 snapshot; you cannot cancel or revert this operation.
1698  
1699 This operation is valid for Redis only.
1700  
1701  
1702 =head2 DeleteUser
1703  
1704 =over
1705  
1706 =item UserId => Str
1707  
1708  
1709 =back
1710  
1711 Each argument is described in detail in: L<Paws::ElastiCache::DeleteUser>
1712  
1713 Returns: a L<Paws::ElastiCache::User> instance
1714  
1715 For Redis engine version 6.x onwards: Deletes a user. The user will be
1716 removed from all user groups and in turn removed from all replication
1717 groups. For more information, see Using Role Based Access Control
1718 (RBAC)
1719 (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.RBAC.html).
1720  
1721  
1722 =head2 DeleteUserGroup
1723  
1724 =over
1725  
1726 =item UserGroupId => Str
1727  
1728  
1729 =back
1730  
1731 Each argument is described in detail in: L<Paws::ElastiCache::DeleteUserGroup>
1732  
1733 Returns: a L<Paws::ElastiCache::UserGroup> instance
1734  
1735 For Redis engine version 6.x onwards: Deletes a user group. The user
1736 group must first be disassociated from the replication group before it
1737 can be deleted. For more information, see Using Role Based Access
1738 Control (RBAC)
1739 (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.RBAC.html).
1740  
1741  
1742 =head2 DescribeCacheClusters
1743  
1744 =over
1745  
1746 =item [CacheClusterId => Str]
1747  
1748 =item [Marker => Str]
1749  
1750 =item [MaxRecords => Int]
1751  
1752 =item [ShowCacheClustersNotInReplicationGroups => Bool]
1753  
1754 =item [ShowCacheNodeInfo => Bool]
1755  
1756  
1757 =back
1758  
1759 Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheClusters>
1760  
1761 Returns: a L<Paws::ElastiCache::CacheClusterMessage> instance
1762  
1763 Returns information about all provisioned clusters if no cluster
1764 identifier is specified, or about a specific cache cluster if a cluster
1765 identifier is supplied.
1766  
1767 By default, abbreviated information about the clusters is returned. You
1768 can use the optional I<ShowCacheNodeInfo> flag to retrieve detailed
1769 information about the cache nodes associated with the clusters. These
1770 details include the DNS address and port for the cache node endpoint.
1771  
1772 If the cluster is in the I<creating> state, only cluster-level
1773 information is displayed until all of the nodes are successfully
1774 provisioned.
1775  
1776 If the cluster is in the I<deleting> state, only cluster-level
1777 information is displayed.
1778  
1779 If cache nodes are currently being added to the cluster, node endpoint
1780 information and creation time for the additional nodes are not
1781 displayed until they are completely provisioned. When the cluster state
1782 is I<available>, the cluster is ready for use.
1783  
1784 If cache nodes are currently being removed from the cluster, no
1785 endpoint information for the removed nodes is displayed.
1786  
1787  
1788 =head2 DescribeCacheEngineVersions
1789  
1790 =over
1791  
1792 =item [CacheParameterGroupFamily => Str]
1793  
1794 =item [DefaultOnly => Bool]
1795  
1796 =item [Engine => Str]
1797  
1798 =item [EngineVersion => Str]
1799  
1800 =item [Marker => Str]
1801  
1802 =item [MaxRecords => Int]
1803  
1804  
1805 =back
1806  
1807 Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheEngineVersions>
1808  
1809 Returns: a L<Paws::ElastiCache::CacheEngineVersionMessage> instance
1810  
1811 Returns a list of the available cache engines and their versions.
1812  
1813  
1814 =head2 DescribeCacheParameterGroups
1815  
1816 =over
1817  
1818 =item [CacheParameterGroupName => Str]
1819  
1820 =item [Marker => Str]
1821  
1822 =item [MaxRecords => Int]
1823  
1824  
1825 =back
1826  
1827 Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheParameterGroups>
1828  
1829 Returns: a L<Paws::ElastiCache::CacheParameterGroupsMessage> instance
1830  
1831 Returns a list of cache parameter group descriptions. If a cache
1832 parameter group name is specified, the list contains only the
1833 descriptions for that group.
1834  
1835  
1836 =head2 DescribeCacheParameters
1837  
1838 =over
1839  
1840 =item CacheParameterGroupName => Str
1841  
1842 =item [Marker => Str]
1843  
1844 =item [MaxRecords => Int]
1845  
1846 =item [Source => Str]
1847  
1848  
1849 =back
1850  
1851 Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheParameters>
1852  
1853 Returns: a L<Paws::ElastiCache::CacheParameterGroupDetails> instance
1854  
1855 Returns the detailed parameter list for a particular cache parameter
1856 group.
1857  
1858  
1859 =head2 DescribeCacheSecurityGroups
1860  
1861 =over
1862  
1863 =item [CacheSecurityGroupName => Str]
1864  
1865 =item [Marker => Str]
1866  
1867 =item [MaxRecords => Int]
1868  
1869  
1870 =back
1871  
1872 Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheSecurityGroups>
1873  
1874 Returns: a L<Paws::ElastiCache::CacheSecurityGroupMessage> instance
1875  
1876 Returns a list of cache security group descriptions. If a cache
1877 security group name is specified, the list contains only the
1878 description of that group. This applicable only when you have
1879 ElastiCache in Classic setup
1880  
1881  
1882 =head2 DescribeCacheSubnetGroups
1883  
1884 =over
1885  
1886 =item [CacheSubnetGroupName => Str]
1887  
1888 =item [Marker => Str]
1889  
1890 =item [MaxRecords => Int]
1891  
1892  
1893 =back
1894  
1895 Each argument is described in detail in: L<Paws::ElastiCache::DescribeCacheSubnetGroups>
1896  
1897 Returns: a L<Paws::ElastiCache::CacheSubnetGroupMessage> instance
1898  
1899 Returns a list of cache subnet group descriptions. If a subnet group
1900 name is specified, the list contains only the description of that
1901 group. This is applicable only when you have ElastiCache in VPC setup.
1902 All ElastiCache clusters now launch in VPC by default.
1903  
1904  
1905 =head2 DescribeEngineDefaultParameters
1906  
1907 =over
1908  
1909 =item CacheParameterGroupFamily => Str
1910  
1911 =item [Marker => Str]
1912  
1913 =item [MaxRecords => Int]
1914  
1915  
1916 =back
1917  
1918 Each argument is described in detail in: L<Paws::ElastiCache::DescribeEngineDefaultParameters>
1919  
1920 Returns: a L<Paws::ElastiCache::DescribeEngineDefaultParametersResult> instance
1921  
1922 Returns the default engine and system parameter information for the
1923 specified cache engine.
1924  
1925  
1926 =head2 DescribeEvents
1927  
1928 =over
1929  
1930 =item [Duration => Int]
1931  
1932 =item [EndTime => Str]
1933  
1934 =item [Marker => Str]
1935  
1936 =item [MaxRecords => Int]
1937  
1938 =item [SourceIdentifier => Str]
1939  
1940 =item [SourceType => Str]
1941  
1942 =item [StartTime => Str]
1943  
1944  
1945 =back
1946  
1947 Each argument is described in detail in: L<Paws::ElastiCache::DescribeEvents>
1948  
1949 Returns: a L<Paws::ElastiCache::EventsMessage> instance
1950  
1951 Returns events related to clusters, cache security groups, and cache
1952 parameter groups. You can obtain events specific to a particular
1953 cluster, cache security group, or cache parameter group by providing
1954 the name as a parameter.
1955  
1956 By default, only the events occurring within the last hour are
1957 returned; however, you can retrieve up to 14 days' worth of events if
1958 necessary.
1959  
1960  
1961 =head2 DescribeGlobalReplicationGroups
1962  
1963 =over
1964  
1965 =item [GlobalReplicationGroupId => Str]
1966  
1967 =item [Marker => Str]
1968  
1969 =item [MaxRecords => Int]
1970  
1971 =item [ShowMemberInfo => Bool]
1972  
1973  
1974 =back
1975  
1976 Each argument is described in detail in: L<Paws::ElastiCache::DescribeGlobalReplicationGroups>
1977  
1978 Returns: a L<Paws::ElastiCache::DescribeGlobalReplicationGroupsResult> instance
1979  
1980 Returns information about a particular global replication group. If no
1981 identifier is specified, returns information about all Global
1982 datastores.
1983  
1984  
1985 =head2 DescribeReplicationGroups
1986  
1987 =over
1988  
1989 =item [Marker => Str]
1990  
1991 =item [MaxRecords => Int]
1992  
1993 =item [ReplicationGroupId => Str]
1994  
1995  
1996 =back
1997  
1998 Each argument is described in detail in: L<Paws::ElastiCache::DescribeReplicationGroups>
1999  
2000 Returns: a L<Paws::ElastiCache::ReplicationGroupMessage> instance
2001  
2002 Returns information about a particular replication group. If no
2003 identifier is specified, C<DescribeReplicationGroups> returns
2004 information about all replication groups.
2005  
2006 This operation is valid for Redis only.
2007  
2008  
2009 =head2 DescribeReservedCacheNodes
2010  
2011 =over
2012  
2013 =item [CacheNodeType => Str]
2014  
2015 =item [Duration => Str]
2016  
2017 =item [Marker => Str]
2018  
2019 =item [MaxRecords => Int]
2020  
2021 =item [OfferingType => Str]
2022  
2023 =item [ProductDescription => Str]
2024  
2025 =item [ReservedCacheNodeId => Str]
2026  
2027 =item [ReservedCacheNodesOfferingId => Str]
2028  
2029  
2030 =back
2031  
2032 Each argument is described in detail in: L<Paws::ElastiCache::DescribeReservedCacheNodes>
2033  
2034 Returns: a L<Paws::ElastiCache::ReservedCacheNodeMessage> instance
2035  
2036 Returns information about reserved cache nodes for this account, or
2037 about a specified reserved cache node.
2038  
2039  
2040 =head2 DescribeReservedCacheNodesOfferings
2041  
2042 =over
2043  
2044 =item [CacheNodeType => Str]
2045  
2046 =item [Duration => Str]
2047  
2048 =item [Marker => Str]
2049  
2050 =item [MaxRecords => Int]
2051  
2052 =item [OfferingType => Str]
2053  
2054 =item [ProductDescription => Str]
2055  
2056 =item [ReservedCacheNodesOfferingId => Str]
2057  
2058  
2059 =back
2060  
2061 Each argument is described in detail in: L<Paws::ElastiCache::DescribeReservedCacheNodesOfferings>
2062  
2063 Returns: a L<Paws::ElastiCache::ReservedCacheNodesOfferingMessage> instance
2064  
2065 Lists available reserved cache node offerings.
2066  
2067  
2068 =head2 DescribeServiceUpdates
2069  
2070 =over
2071  
2072 =item [Marker => Str]
2073  
2074 =item [MaxRecords => Int]
2075  
2076 =item [ServiceUpdateName => Str]
2077  
2078 =item [ServiceUpdateStatus => ArrayRef[Str|Undef]]
2079  
2080  
2081 =back
2082  
2083 Each argument is described in detail in: L<Paws::ElastiCache::DescribeServiceUpdates>
2084  
2085 Returns: a L<Paws::ElastiCache::ServiceUpdatesMessage> instance
2086  
2087 Returns details of the service updates
2088  
2089  
2090 =head2 DescribeSnapshots
2091  
2092 =over
2093  
2094 =item [CacheClusterId => Str]
2095  
2096 =item [Marker => Str]
2097  
2098 =item [MaxRecords => Int]
2099  
2100 =item [ReplicationGroupId => Str]
2101  
2102 =item [ShowNodeGroupConfig => Bool]
2103  
2104 =item [SnapshotName => Str]
2105  
2106 =item [SnapshotSource => Str]
2107  
2108  
2109 =back
2110  
2111 Each argument is described in detail in: L<Paws::ElastiCache::DescribeSnapshots>
2112  
2113 Returns: a L<Paws::ElastiCache::DescribeSnapshotsListMessage> instance
2114  
2115 Returns information about cluster or replication group snapshots. By
2116 default, C<DescribeSnapshots> lists all of your snapshots; it can
2117 optionally describe a single snapshot, or just the snapshots associated
2118 with a particular cache cluster.
2119  
2120 This operation is valid for Redis only.
2121  
2122  
2123 =head2 DescribeUpdateActions
2124  
2125 =over
2126  
2127 =item [CacheClusterIds => ArrayRef[Str|Undef]]
2128  
2129 =item [Engine => Str]
2130  
2131 =item [Marker => Str]
2132  
2133 =item [MaxRecords => Int]
2134  
2135 =item [ReplicationGroupIds => ArrayRef[Str|Undef]]
2136  
2137 =item [ServiceUpdateName => Str]
2138  
2139 =item [ServiceUpdateStatus => ArrayRef[Str|Undef]]
2140  
2141 =item [ServiceUpdateTimeRange => L<Paws::ElastiCache::TimeRangeFilter>]
2142  
2143 =item [ShowNodeLevelUpdateStatus => Bool]
2144  
2145 =item [UpdateActionStatus => ArrayRef[Str|Undef]]
2146  
2147  
2148 =back
2149  
2150 Each argument is described in detail in: L<Paws::ElastiCache::DescribeUpdateActions>
2151  
2152 Returns: a L<Paws::ElastiCache::UpdateActionsMessage> instance
2153  
2154 Returns details of the update actions
2155  
2156  
2157 =head2 DescribeUserGroups
2158  
2159 =over
2160  
2161 =item [Marker => Str]
2162  
2163 =item [MaxRecords => Int]
2164  
2165 =item [UserGroupId => Str]
2166  
2167  
2168 =back
2169  
2170 Each argument is described in detail in: L<Paws::ElastiCache::DescribeUserGroups>
2171  
2172 Returns: a L<Paws::ElastiCache::DescribeUserGroupsResult> instance
2173  
2174 Returns a list of user groups.
2175  
2176  
2177 =head2 DescribeUsers
2178  
2179 =over
2180  
2181 =item [Engine => Str]
2182  
2183 =item [Filters => ArrayRef[L<Paws::ElastiCache::Filter>]]
2184  
2185 =item [Marker => Str]
2186  
2187 =item [MaxRecords => Int]
2188  
2189 =item [UserId => Str]
2190  
2191  
2192 =back
2193  
2194 Each argument is described in detail in: L<Paws::ElastiCache::DescribeUsers>
2195  
2196 Returns: a L<Paws::ElastiCache::DescribeUsersResult> instance
2197  
2198 Returns a list of users.
2199  
2200  
2201 =head2 DisassociateGlobalReplicationGroup
2202  
2203 =over
2204  
2205 =item GlobalReplicationGroupId => Str
2206  
2207 =item ReplicationGroupId => Str
2208  
2209 =item ReplicationGroupRegion => Str
2210  
2211  
2212 =back
2213  
2214 Each argument is described in detail in: L<Paws::ElastiCache::DisassociateGlobalReplicationGroup>
2215  
2216 Returns: a L<Paws::ElastiCache::DisassociateGlobalReplicationGroupResult> instance
2217  
2218 Remove a secondary cluster from the Global datastore using the Global
2219 datastore name. The secondary cluster will no longer receive updates
2220 from the primary cluster, but will remain as a standalone cluster in
2221 that AWS region.
2222  
2223  
2224 =head2 FailoverGlobalReplicationGroup
2225  
2226 =over
2227  
2228 =item GlobalReplicationGroupId => Str
2229  
2230 =item PrimaryRegion => Str
2231  
2232 =item PrimaryReplicationGroupId => Str
2233  
2234  
2235 =back
2236  
2237 Each argument is described in detail in: L<Paws::ElastiCache::FailoverGlobalReplicationGroup>
2238  
2239 Returns: a L<Paws::ElastiCache::FailoverGlobalReplicationGroupResult> instance
2240  
2241 Used to failover the primary region to a selected secondary region. The
2242 selected secondary region will become primary, and all other clusters
2243 will become secondary.
2244  
2245  
2246 =head2 IncreaseNodeGroupsInGlobalReplicationGroup
2247  
2248 =over
2249  
2250 =item ApplyImmediately => Bool
2251  
2252 =item GlobalReplicationGroupId => Str
2253  
2254 =item NodeGroupCount => Int
2255  
2256 =item [RegionalConfigurations => ArrayRef[L<Paws::ElastiCache::RegionalConfiguration>]]
2257  
2258  
2259 =back
2260  
2261 Each argument is described in detail in: L<Paws::ElastiCache::IncreaseNodeGroupsInGlobalReplicationGroup>
2262  
2263 Returns: a L<Paws::ElastiCache::IncreaseNodeGroupsInGlobalReplicationGroupResult> instance
2264  
2265 Increase the number of node groups in the Global datastore
2266  
2267  
2268 =head2 IncreaseReplicaCount
2269  
2270 =over
2271  
2272 =item ApplyImmediately => Bool
2273  
2274 =item ReplicationGroupId => Str
2275  
2276 =item [NewReplicaCount => Int]
2277  
2278 =item [ReplicaConfiguration => ArrayRef[L<Paws::ElastiCache::ConfigureShard>]]
2279  
2280  
2281 =back
2282  
2283 Each argument is described in detail in: L<Paws::ElastiCache::IncreaseReplicaCount>
2284  
2285 Returns: a L<Paws::ElastiCache::IncreaseReplicaCountResult> instance
2286  
2287 Dynamically increases the number of replicas in a Redis (cluster mode
2288 disabled) replication group or the number of replica nodes in one or
2289 more node groups (shards) of a Redis (cluster mode enabled) replication
2290 group. This operation is performed with no cluster down time.
2291  
2292  
2293 =head2 ListAllowedNodeTypeModifications
2294  
2295 =over
2296  
2297 =item [CacheClusterId => Str]
2298  
2299 =item [ReplicationGroupId => Str]
2300  
2301  
2302 =back
2303  
2304 Each argument is described in detail in: L<Paws::ElastiCache::ListAllowedNodeTypeModifications>
2305  
2306 Returns: a L<Paws::ElastiCache::AllowedNodeTypeModificationsMessage> instance
2307  
2308 Lists all available node types that you can scale your Redis cluster's
2309 or replication group's current node type.
2310  
2311 When you use the C<ModifyCacheCluster> or C<ModifyReplicationGroup>
2312 operations to scale your cluster or replication group, the value of the
2313 C<CacheNodeType> parameter must be one of the node types returned by
2314 this operation.
2315  
2316  
2317 =head2 ListTagsForResource
2318  
2319 =over
2320  
2321 =item ResourceName => Str
2322  
2323  
2324 =back
2325  
2326 Each argument is described in detail in: L<Paws::ElastiCache::ListTagsForResource>
2327  
2328 Returns: a L<Paws::ElastiCache::TagListMessage> instance
2329  
2330 Lists all tags currently on a named resource.
2331  
2332 A tag is a key-value pair where the key and value are case-sensitive.
2333 You can use tags to categorize and track all your ElastiCache
2334 resources, with the exception of global replication group. When you add
2335 or remove tags on replication groups, those actions will be replicated
2336 to all nodes in the replication group. For more information, see
2337 Resource-level permissions
2338 (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/IAM.ResourceLevelPermissions.html).
2339  
2340 If the cluster is not in the I<available> state, C<ListTagsForResource>
2341 returns an error.
2342  
2343  
2344 =head2 ModifyCacheCluster
2345  
2346 =over
2347  
2348 =item CacheClusterId => Str
2349  
2350 =item [ApplyImmediately => Bool]
2351  
2352 =item [AuthToken => Str]
2353  
2354 =item [AuthTokenUpdateStrategy => Str]
2355  
2356 =item [AutoMinorVersionUpgrade => Bool]
2357  
2358 =item [AZMode => Str]
2359  
2360 =item [CacheNodeIdsToRemove => ArrayRef[Str|Undef]]
2361  
2362 =item [CacheNodeType => Str]
2363  
2364 =item [CacheParameterGroupName => Str]
2365  
2366 =item [CacheSecurityGroupNames => ArrayRef[Str|Undef]]
2367  
2368 =item [EngineVersion => Str]
2369  
2370 =item [LogDeliveryConfigurations => ArrayRef[L<Paws::ElastiCache::LogDeliveryConfigurationRequest>]]
2371  
2372 =item [NewAvailabilityZones => ArrayRef[Str|Undef]]
2373  
2374 =item [NotificationTopicArn => Str]
2375  
2376 =item [NotificationTopicStatus => Str]
2377  
2378 =item [NumCacheNodes => Int]
2379  
2380 =item [PreferredMaintenanceWindow => Str]
2381  
2382 =item [SecurityGroupIds => ArrayRef[Str|Undef]]
2383  
2384 =item [SnapshotRetentionLimit => Int]
2385  
2386 =item [SnapshotWindow => Str]
2387  
2388  
2389 =back
2390  
2391 Each argument is described in detail in: L<Paws::ElastiCache::ModifyCacheCluster>
2392  
2393 Returns: a L<Paws::ElastiCache::ModifyCacheClusterResult> instance
2394  
2395 Modifies the settings for a cluster. You can use this operation to
2396 change one or more cluster configuration parameters by specifying the
2397 parameters and the new values.
2398  
2399  
2400 =head2 ModifyCacheParameterGroup
2401  
2402 =over
2403  
2404 =item CacheParameterGroupName => Str
2405  
2406 =item ParameterNameValues => ArrayRef[L<Paws::ElastiCache::ParameterNameValue>]
2407  
2408  
2409 =back
2410  
2411 Each argument is described in detail in: L<Paws::ElastiCache::ModifyCacheParameterGroup>
2412  
2413 Returns: a L<Paws::ElastiCache::CacheParameterGroupNameMessage> instance
2414  
2415 Modifies the parameters of a cache parameter group. You can modify up
2416 to 20 parameters in a single request by submitting a list parameter
2417 name and value pairs.
2418  
2419  
2420 =head2 ModifyCacheSubnetGroup
2421  
2422 =over
2423  
2424 =item CacheSubnetGroupName => Str
2425  
2426 =item [CacheSubnetGroupDescription => Str]
2427  
2428 =item [SubnetIds => ArrayRef[Str|Undef]]
2429  
2430  
2431 =back
2432  
2433 Each argument is described in detail in: L<Paws::ElastiCache::ModifyCacheSubnetGroup>
2434  
2435 Returns: a L<Paws::ElastiCache::ModifyCacheSubnetGroupResult> instance
2436  
2437 Modifies an existing cache subnet group.
2438  
2439  
2440 =head2 ModifyGlobalReplicationGroup
2441  
2442 =over
2443  
2444 =item ApplyImmediately => Bool
2445  
2446 =item GlobalReplicationGroupId => Str
2447  
2448 =item [AutomaticFailoverEnabled => Bool]
2449  
2450 =item [CacheNodeType => Str]
2451  
2452 =item [CacheParameterGroupName => Str]
2453  
2454 =item [EngineVersion => Str]
2455  
2456 =item [GlobalReplicationGroupDescription => Str]
2457  
2458  
2459 =back
2460  
2461 Each argument is described in detail in: L<Paws::ElastiCache::ModifyGlobalReplicationGroup>
2462  
2463 Returns: a L<Paws::ElastiCache::ModifyGlobalReplicationGroupResult> instance
2464  
2465 Modifies the settings for a Global datastore.
2466  
2467  
2468 =head2 ModifyReplicationGroup
2469  
2470 =over
2471  
2472 =item ReplicationGroupId => Str
2473  
2474 =item [ApplyImmediately => Bool]
2475  
2476 =item [AuthToken => Str]
2477  
2478 =item [AuthTokenUpdateStrategy => Str]
2479  
2480 =item [AutomaticFailoverEnabled => Bool]
2481  
2482 =item [AutoMinorVersionUpgrade => Bool]
2483  
2484 =item [CacheNodeType => Str]
2485  
2486 =item [CacheParameterGroupName => Str]
2487  
2488 =item [CacheSecurityGroupNames => ArrayRef[Str|Undef]]
2489  
2490 =item [EngineVersion => Str]
2491  
2492 =item [LogDeliveryConfigurations => ArrayRef[L<Paws::ElastiCache::LogDeliveryConfigurationRequest>]]
2493  
2494 =item [MultiAZEnabled => Bool]
2495  
2496 =item [NodeGroupId => Str]
2497  
2498 =item [NotificationTopicArn => Str]
2499  
2500 =item [NotificationTopicStatus => Str]
2501  
2502 =item [PreferredMaintenanceWindow => Str]
2503  
2504 =item [PrimaryClusterId => Str]
2505  
2506 =item [RemoveUserGroups => Bool]
2507  
2508 =item [ReplicationGroupDescription => Str]
2509  
2510 =item [SecurityGroupIds => ArrayRef[Str|Undef]]
2511  
2512 =item [SnapshotRetentionLimit => Int]
2513  
2514 =item [SnapshottingClusterId => Str]
2515  
2516 =item [SnapshotWindow => Str]
2517  
2518 =item [UserGroupIdsToAdd => ArrayRef[Str|Undef]]
2519  
2520 =item [UserGroupIdsToRemove => ArrayRef[Str|Undef]]
2521  
2522  
2523 =back
2524  
2525 Each argument is described in detail in: L<Paws::ElastiCache::ModifyReplicationGroup>
2526  
2527 Returns: a L<Paws::ElastiCache::ModifyReplicationGroupResult> instance
2528  
2529 Modifies the settings for a replication group.
2530  
2531 =over
2532  
2533 =item *
2534  
2535 Scaling for Amazon ElastiCache for Redis (cluster mode enabled)
2536 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/scaling-redis-cluster-mode-enabled.html)
2537 in the ElastiCache User Guide
2538  
2539 =item *
2540  
2541 ModifyReplicationGroupShardConfiguration
2542 (https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroupShardConfiguration.html)
2543 in the ElastiCache API Reference
2544  
2545 =back
2546  
2547 This operation is valid for Redis only.
2548  
2549  
2550 =head2 ModifyReplicationGroupShardConfiguration
2551  
2552 =over
2553  
2554 =item ApplyImmediately => Bool
2555  
2556 =item NodeGroupCount => Int
2557  
2558 =item ReplicationGroupId => Str
2559  
2560 =item [NodeGroupsToRemove => ArrayRef[Str|Undef]]
2561  
2562 =item [NodeGroupsToRetain => ArrayRef[Str|Undef]]
2563  
2564 =item [ReshardingConfiguration => ArrayRef[L<Paws::ElastiCache::ReshardingConfiguration>]]
2565  
2566  
2567 =back
2568  
2569 Each argument is described in detail in: L<Paws::ElastiCache::ModifyReplicationGroupShardConfiguration>
2570  
2571 Returns: a L<Paws::ElastiCache::ModifyReplicationGroupShardConfigurationResult> instance
2572  
2573 Modifies a replication group's shards (node groups) by allowing you to
2574 add shards, remove shards, or rebalance the keyspaces among existing
2575 shards.
2576  
2577  
2578 =head2 ModifyUser
2579  
2580 =over
2581  
2582 =item UserId => Str
2583  
2584 =item [AccessString => Str]
2585  
2586 =item [AppendAccessString => Str]
2587  
2588 =item [NoPasswordRequired => Bool]
2589  
2590 =item [Passwords => ArrayRef[Str|Undef]]
2591  
2592  
2593 =back
2594  
2595 Each argument is described in detail in: L<Paws::ElastiCache::ModifyUser>
2596  
2597 Returns: a L<Paws::ElastiCache::User> instance
2598  
2599 Changes user password(s) and/or access string.
2600  
2601  
2602 =head2 ModifyUserGroup
2603  
2604 =over
2605  
2606 =item UserGroupId => Str
2607  
2608 =item [UserIdsToAdd => ArrayRef[Str|Undef]]
2609  
2610 =item [UserIdsToRemove => ArrayRef[Str|Undef]]
2611  
2612  
2613 =back
2614  
2615 Each argument is described in detail in: L<Paws::ElastiCache::ModifyUserGroup>
2616  
2617 Returns: a L<Paws::ElastiCache::UserGroup> instance
2618  
2619 Changes the list of users that belong to the user group.
2620  
2621  
2622 =head2 PurchaseReservedCacheNodesOffering
2623  
2624 =over
2625  
2626 =item ReservedCacheNodesOfferingId => Str
2627  
2628 =item [CacheNodeCount => Int]
2629  
2630 =item [ReservedCacheNodeId => Str]
2631  
2632 =item [Tags => ArrayRef[L<Paws::ElastiCache::Tag>]]
2633  
2634  
2635 =back
2636  
2637 Each argument is described in detail in: L<Paws::ElastiCache::PurchaseReservedCacheNodesOffering>
2638  
2639 Returns: a L<Paws::ElastiCache::PurchaseReservedCacheNodesOfferingResult> instance
2640  
2641 Allows you to purchase a reserved cache node offering. Reserved nodes
2642 are not eligible for cancellation and are non-refundable. For more
2643 information, see Managing Costs with Reserved Nodes
2644 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/reserved-nodes.html)
2645 for Redis or Managing Costs with Reserved Nodes
2646 (https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/reserved-nodes.html)
2647 for Memcached.
2648  
2649  
2650 =head2 RebalanceSlotsInGlobalReplicationGroup
2651  
2652 =over
2653  
2654 =item ApplyImmediately => Bool
2655  
2656 =item GlobalReplicationGroupId => Str
2657  
2658  
2659 =back
2660  
2661 Each argument is described in detail in: L<Paws::ElastiCache::RebalanceSlotsInGlobalReplicationGroup>
2662  
2663 Returns: a L<Paws::ElastiCache::RebalanceSlotsInGlobalReplicationGroupResult> instance
2664  
2665 Redistribute slots to ensure uniform distribution across existing
2666 shards in the cluster.
2667  
2668  
2669 =head2 RebootCacheCluster
2670  
2671 =over
2672  
2673 =item CacheClusterId => Str
2674  
2675 =item CacheNodeIdsToReboot => ArrayRef[Str|Undef]
2676  
2677  
2678 =back
2679  
2680 Each argument is described in detail in: L<Paws::ElastiCache::RebootCacheCluster>
2681  
2682 Returns: a L<Paws::ElastiCache::RebootCacheClusterResult> instance
2683  
2684 Reboots some, or all, of the cache nodes within a provisioned cluster.
2685 This operation applies any modified cache parameter groups to the
2686 cluster. The reboot operation takes place as soon as possible, and
2687 results in a momentary outage to the cluster. During the reboot, the
2688 cluster status is set to REBOOTING.
2689  
2690 The reboot causes the contents of the cache (for each cache node being
2691 rebooted) to be lost.
2692  
2693 When the reboot is complete, a cluster event is created.
2694  
2695 Rebooting a cluster is currently supported on Memcached and Redis
2696 (cluster mode disabled) clusters. Rebooting is not supported on Redis
2697 (cluster mode enabled) clusters.
2698  
2699 If you make changes to parameters that require a Redis (cluster mode
2700 enabled) cluster reboot for the changes to be applied, see Rebooting a
2701 Cluster
2702 (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.Rebooting.html)
2703 for an alternate process.
2704  
2705  
2706 =head2 RemoveTagsFromResource
2707  
2708 =over
2709  
2710 =item ResourceName => Str
2711  
2712 =item TagKeys => ArrayRef[Str|Undef]
2713  
2714  
2715 =back
2716  
2717 Each argument is described in detail in: L<Paws::ElastiCache::RemoveTagsFromResource>
2718  
2719 Returns: a L<Paws::ElastiCache::TagListMessage> instance
2720  
2721 Removes the tags identified by the C<TagKeys> list from the named
2722 resource. A tag is a key-value pair where the key and value are
2723 case-sensitive. You can use tags to categorize and track all your
2724 ElastiCache resources, with the exception of global replication group.
2725 When you add or remove tags on replication groups, those actions will
2726 be replicated to all nodes in the replication group. For more
2727 information, see Resource-level permissions
2728 (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/IAM.ResourceLevelPermissions.html).
2729  
2730  
2731 =head2 ResetCacheParameterGroup
2732  
2733 =over
2734  
2735 =item CacheParameterGroupName => Str
2736  
2737 =item [ParameterNameValues => ArrayRef[L<Paws::ElastiCache::ParameterNameValue>]]
2738  
2739 =item [ResetAllParameters => Bool]
2740  
2741  
2742 =back
2743  
2744 Each argument is described in detail in: L<Paws::ElastiCache::ResetCacheParameterGroup>
2745  
2746 Returns: a L<Paws::ElastiCache::CacheParameterGroupNameMessage> instance
2747  
2748 Modifies the parameters of a cache parameter group to the engine or
2749 system default value. You can reset specific parameters by submitting a
2750 list of parameter names. To reset the entire cache parameter group,
2751 specify the C<ResetAllParameters> and C<CacheParameterGroupName>
2752 parameters.
2753  
2754  
2755 =head2 RevokeCacheSecurityGroupIngress
2756  
2757 =over
2758  
2759 =item CacheSecurityGroupName => Str
2760  
2761 =item EC2SecurityGroupName => Str
2762  
2763 =item EC2SecurityGroupOwnerId => Str
2764  
2765  
2766 =back
2767  
2768 Each argument is described in detail in: L<Paws::ElastiCache::RevokeCacheSecurityGroupIngress>
2769  
2770 Returns: a L<Paws::ElastiCache::RevokeCacheSecurityGroupIngressResult> instance
2771  
2772 Revokes ingress from a cache security group. Use this operation to
2773 disallow access from an Amazon EC2 security group that had been
2774 previously authorized.
2775  
2776  
2777 =head2 StartMigration
2778  
2779 =over
2780  
2781 =item CustomerNodeEndpointList => ArrayRef[L<Paws::ElastiCache::CustomerNodeEndpoint>]
2782  
2783 =item ReplicationGroupId => Str
2784  
2785  
2786 =back
2787  
2788 Each argument is described in detail in: L<Paws::ElastiCache::StartMigration>
2789  
2790 Returns: a L<Paws::ElastiCache::StartMigrationResponse> instance
2791  
2792 Start the migration of data.
2793  
2794  
2795 =head2 TestFailover
2796  
2797 =over
2798  
2799 =item NodeGroupId => Str
2800  
2801 =item ReplicationGroupId => Str
2802  
2803  
2804 =back
2805  
2806 Each argument is described in detail in: L<Paws::ElastiCache::TestFailover>
2807  
2808 Returns: a L<Paws::ElastiCache::TestFailoverResult> instance
2809  
2810 Represents the input of a C<TestFailover> operation which test
2811 automatic failover on a specified node group (called shard in the
2812 console) in a replication group (called cluster in the console).
2813  
2814 B<Note the following>
2815  
2816 =over
2817  
2818 =item *
2819  
2820 A customer can use this operation to test automatic failover on up to 5
2821 shards (called node groups in the ElastiCache API and AWS CLI) in any
2822 rolling 24-hour period.
2823  
2824 =item *
2825  
2826 If calling this operation on shards in different clusters (called
2827 replication groups in the API and CLI), the calls can be made
2828 concurrently.
2829  
2830 =item *
2831  
2832 If calling this operation multiple times on different shards in the
2833 same Redis (cluster mode enabled) replication group, the first node
2834 replacement must complete before a subsequent call can be made.
2835  
2836 =item *
2837  
2838 To determine whether the node replacement is complete you can check
2839 Events using the Amazon ElastiCache console, the AWS CLI, or the
2840 ElastiCache API. Look for the following automatic failover related
2841 events, listed here in order of occurrance:
2842  
2843 =over
2844  
2845 =item 1.
2846  
2847 Replication group message: C<Test Failover API called for node group
2848 E<lt>node-group-idE<gt>>
2849  
2850 =item 2.
2851  
2852 Cache cluster message: C<Failover from primary node
2853 E<lt>primary-node-idE<gt> to replica node E<lt>node-idE<gt> completed>
2854  
2855 =item 3.
2856  
2857 Replication group message: C<Failover from primary node
2858 E<lt>primary-node-idE<gt> to replica node E<lt>node-idE<gt> completed>
2859  
2860 =item 4.
2861  
2862 Cache cluster message: C<Recovering cache nodes E<lt>node-idE<gt>>
2863  
2864 =item 5.
2865  
2866 Cache cluster message: C<Finished recovery for cache nodes
2867 E<lt>node-idE<gt>>
2868  
2869 =back
2870  
2871 For more information see:
2872  
2873 =over
2874  
2875 =item *
2876  
2877 Viewing ElastiCache Events
2878 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/ECEvents.Viewing.html)
2879 in the I<ElastiCache User Guide>
2880  
2881 =item *
2882  
2883 DescribeEvents
2884 (https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeEvents.html)
2885 in the ElastiCache API Reference
2886  
2887 =back
2888  
2889 =back
2890  
2891 Also see, Testing Multi-AZ
2892 (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/AutoFailover.html#auto-failover-test)
2893 in the I<ElastiCache User Guide>.
2894  
2895  
2896  
2897  
2898 =head1 PAGINATORS
2899  
2900 Paginator methods are helpers that repetively call methods that return partial results
2901  
2902 =head2 DescribeAllCacheClusters(sub { },[CacheClusterId => Str, Marker => Str, MaxRecords => Int, ShowCacheClustersNotInReplicationGroups => Bool, ShowCacheNodeInfo => Bool])
2903  
2904 =head2 DescribeAllCacheClusters([CacheClusterId => Str, Marker => Str, MaxRecords => Int, ShowCacheClustersNotInReplicationGroups => Bool, ShowCacheNodeInfo => Bool])
2905  
2906  
2907 If passed a sub as first parameter, it will call the sub for each element found in :
2908  
2909 - CacheClusters, passing the object as the first parameter, and the string 'CacheClusters' as the second parameter
2910  
2911 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.
2912  
2913  
2914 =head2 DescribeAllCacheEngineVersions(sub { },[CacheParameterGroupFamily => Str, DefaultOnly => Bool, Engine => Str, EngineVersion => Str, Marker => Str, MaxRecords => Int])
2915  
2916 =head2 DescribeAllCacheEngineVersions([CacheParameterGroupFamily => Str, DefaultOnly => Bool, Engine => Str, EngineVersion => Str, Marker => Str, MaxRecords => Int])
2917  
2918  
2919 If passed a sub as first parameter, it will call the sub for each element found in :
2920  
2921 - CacheEngineVersions, passing the object as the first parameter, and the string 'CacheEngineVersions' as the second parameter
2922  
2923 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.
2924  
2925  
2926 =head2 DescribeAllCacheParameterGroups(sub { },[CacheParameterGroupName => Str, Marker => Str, MaxRecords => Int])
2927  
2928 =head2 DescribeAllCacheParameterGroups([CacheParameterGroupName => Str, Marker => Str, MaxRecords => Int])
2929  
2930  
2931 If passed a sub as first parameter, it will call the sub for each element found in :
2932  
2933 - CacheParameterGroups, passing the object as the first parameter, and the string 'CacheParameterGroups' as the second parameter
2934  
2935 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.
2936  
2937  
2938 =head2 DescribeAllCacheParameters(sub { },CacheParameterGroupName => Str, [Marker => Str, MaxRecords => Int, Source => Str])
2939  
2940 =head2 DescribeAllCacheParameters(CacheParameterGroupName => Str, [Marker => Str, MaxRecords => Int, Source => Str])
2941  
2942  
2943 If passed a sub as first parameter, it will call the sub for each element found in :
2944  
2945 - Parameters, passing the object as the first parameter, and the string 'Parameters' as the second parameter
2946  
2947 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.
2948  
2949  
2950 =head2 DescribeAllCacheSecurityGroups(sub { },[CacheSecurityGroupName => Str, Marker => Str, MaxRecords => Int])
2951  
2952 =head2 DescribeAllCacheSecurityGroups([CacheSecurityGroupName => Str, Marker => Str, MaxRecords => Int])
2953  
2954  
2955 If passed a sub as first parameter, it will call the sub for each element found in :
2956  
2957 - CacheSecurityGroups, passing the object as the first parameter, and the string 'CacheSecurityGroups' as the second parameter
2958  
2959 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.
2960  
2961  
2962 =head2 DescribeAllCacheSubnetGroups(sub { },[CacheSubnetGroupName => Str, Marker => Str, MaxRecords => Int])
2963  
2964 =head2 DescribeAllCacheSubnetGroups([CacheSubnetGroupName => Str, Marker => Str, MaxRecords => Int])
2965  
2966  
2967 If passed a sub as first parameter, it will call the sub for each element found in :
2968  
2969 - CacheSubnetGroups, passing the object as the first parameter, and the string 'CacheSubnetGroups' as the second parameter
2970  
2971 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.
2972  
2973  
2974 =head2 DescribeAllEngineDefaultParameters(sub { },CacheParameterGroupFamily => Str, [Marker => Str, MaxRecords => Int])
2975  
2976 =head2 DescribeAllEngineDefaultParameters(CacheParameterGroupFamily => Str, [Marker => Str, MaxRecords => Int])
2977  
2978  
2979 If passed a sub as first parameter, it will call the sub for each element found in :
2980  
2981 - EngineDefaults.Parameters, passing the object as the first parameter, and the string 'EngineDefaults.Parameters' as the second parameter
2982  
2983 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.
2984  
2985  
2986 =head2 DescribeAllEvents(sub { },[Duration => Int, EndTime => Str, Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
2987  
2988 =head2 DescribeAllEvents([Duration => Int, EndTime => Str, Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
2989  
2990  
2991 If passed a sub as first parameter, it will call the sub for each element found in :
2992  
2993 - Events, passing the object as the first parameter, and the string 'Events' as the second parameter
2994  
2995 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.
2996  
2997  
2998 =head2 DescribeAllGlobalReplicationGroups(sub { },[GlobalReplicationGroupId => Str, Marker => Str, MaxRecords => Int, ShowMemberInfo => Bool])
2999  
3000 =head2 DescribeAllGlobalReplicationGroups([GlobalReplicationGroupId => Str, Marker => Str, MaxRecords => Int, ShowMemberInfo => Bool])
3001  
3002  
3003 If passed a sub as first parameter, it will call the sub for each element found in :
3004  
3005 - GlobalReplicationGroups, passing the object as the first parameter, and the string 'GlobalReplicationGroups' as the second parameter
3006  
3007 If not, it will return a a L<Paws::ElastiCache::DescribeGlobalReplicationGroupsResult> 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.
3008  
3009  
3010 =head2 DescribeAllReplicationGroups(sub { },[Marker => Str, MaxRecords => Int, ReplicationGroupId => Str])
3011  
3012 =head2 DescribeAllReplicationGroups([Marker => Str, MaxRecords => Int, ReplicationGroupId => Str])
3013  
3014  
3015 If passed a sub as first parameter, it will call the sub for each element found in :
3016  
3017 - ReplicationGroups, passing the object as the first parameter, and the string 'ReplicationGroups' as the second parameter
3018  
3019 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.
3020  
3021  
3022 =head2 DescribeAllReservedCacheNodes(sub { },[CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodeId => Str, ReservedCacheNodesOfferingId => Str])
3023  
3024 =head2 DescribeAllReservedCacheNodes([CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodeId => Str, ReservedCacheNodesOfferingId => Str])
3025  
3026  
3027 If passed a sub as first parameter, it will call the sub for each element found in :
3028  
3029 - ReservedCacheNodes, passing the object as the first parameter, and the string 'ReservedCacheNodes' as the second parameter
3030  
3031 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.
3032  
3033  
3034 =head2 DescribeAllReservedCacheNodesOfferings(sub { },[CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodesOfferingId => Str])
3035  
3036 =head2 DescribeAllReservedCacheNodesOfferings([CacheNodeType => Str, Duration => Str, Marker => Str, MaxRecords => Int, OfferingType => Str, ProductDescription => Str, ReservedCacheNodesOfferingId => Str])
3037  
3038  
3039 If passed a sub as first parameter, it will call the sub for each element found in :
3040  
3041 - ReservedCacheNodesOfferings, passing the object as the first parameter, and the string 'ReservedCacheNodesOfferings' as the second parameter
3042  
3043 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.
3044  
3045  
3046 =head2 DescribeAllServiceUpdates(sub { },[Marker => Str, MaxRecords => Int, ServiceUpdateName => Str, ServiceUpdateStatus => ArrayRef[Str|Undef]])
3047  
3048 =head2 DescribeAllServiceUpdates([Marker => Str, MaxRecords => Int, ServiceUpdateName => Str, ServiceUpdateStatus => ArrayRef[Str|Undef]])
3049  
3050  
3051 If passed a sub as first parameter, it will call the sub for each element found in :
3052  
3053 - ServiceUpdates, passing the object as the first parameter, and the string 'ServiceUpdates' as the second parameter
3054  
3055 If not, it will return a a L<Paws::ElastiCache::ServiceUpdatesMessage> 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.
3056  
3057  
3058 =head2 DescribeAllSnapshots(sub { },[CacheClusterId => Str, Marker => Str, MaxRecords => Int, ReplicationGroupId => Str, ShowNodeGroupConfig => Bool, SnapshotName => Str, SnapshotSource => Str])
3059  
3060 =head2 DescribeAllSnapshots([CacheClusterId => Str, Marker => Str, MaxRecords => Int, ReplicationGroupId => Str, ShowNodeGroupConfig => Bool, SnapshotName => Str, SnapshotSource => Str])
3061  
3062  
3063 If passed a sub as first parameter, it will call the sub for each element found in :
3064  
3065 - Snapshots, passing the object as the first parameter, and the string 'Snapshots' as the second parameter
3066  
3067 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.
3068  
3069  
3070 =head2 DescribeAllUpdateActions(sub { },[CacheClusterIds => ArrayRef[Str|Undef], Engine => Str, Marker => Str, MaxRecords => Int, ReplicationGroupIds => ArrayRef[Str|Undef], ServiceUpdateName => Str, ServiceUpdateStatus => ArrayRef[Str|Undef], ServiceUpdateTimeRange => L<Paws::ElastiCache::TimeRangeFilter>, ShowNodeLevelUpdateStatus => Bool, UpdateActionStatus => ArrayRef[Str|Undef]])
3071  
3072 =head2 DescribeAllUpdateActions([CacheClusterIds => ArrayRef[Str|Undef], Engine => Str, Marker => Str, MaxRecords => Int, ReplicationGroupIds => ArrayRef[Str|Undef], ServiceUpdateName => Str, ServiceUpdateStatus => ArrayRef[Str|Undef], ServiceUpdateTimeRange => L<Paws::ElastiCache::TimeRangeFilter>, ShowNodeLevelUpdateStatus => Bool, UpdateActionStatus => ArrayRef[Str|Undef]])
3073  
3074  
3075 If passed a sub as first parameter, it will call the sub for each element found in :
3076  
3077 - UpdateActions, passing the object as the first parameter, and the string 'UpdateActions' as the second parameter
3078  
3079 If not, it will return a a L<Paws::ElastiCache::UpdateActionsMessage> 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.
3080  
3081  
3082 =head2 DescribeAllUserGroups(sub { },[Marker => Str, MaxRecords => Int, UserGroupId => Str])
3083  
3084 =head2 DescribeAllUserGroups([Marker => Str, MaxRecords => Int, UserGroupId => Str])
3085  
3086  
3087 If passed a sub as first parameter, it will call the sub for each element found in :
3088  
3089 - UserGroups, passing the object as the first parameter, and the string 'UserGroups' as the second parameter
3090  
3091 If not, it will return a a L<Paws::ElastiCache::DescribeUserGroupsResult> 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.
3092  
3093  
3094 =head2 DescribeAllUsers(sub { },[Engine => Str, Filters => ArrayRef[L<Paws::ElastiCache::Filter>], Marker => Str, MaxRecords => Int, UserId => Str])
3095  
3096 =head2 DescribeAllUsers([Engine => Str, Filters => ArrayRef[L<Paws::ElastiCache::Filter>], Marker => Str, MaxRecords => Int, UserId => Str])
3097  
3098  
3099 If passed a sub as first parameter, it will call the sub for each element found in :
3100  
3101 - Users, passing the object as the first parameter, and the string 'Users' as the second parameter
3102  
3103 If not, it will return a a L<Paws::ElastiCache::DescribeUsersResult> 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.
3104  
3105  
3106  
3107  
3108  
3109 =head1 SEE ALSO
3110  
3111 This service class forms part of L<Paws>
3112  
3113 =head1 BUGS and CONTRIBUTIONS
3114  
3115 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
3116  
3117 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
3118  
3119 =cut
3120