blib/lib/Paws/FSX.pm untested

filter: Statementstmt 0.0% 0 / 129 Branchbran 0.0% 0 / 12 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 28 Podpod 0.0% 0 / 27 totaltotal 0.0% 0 / 196 CC 7 SCAR 15.4
CC
7
Cov
0%
DescribeAllBackups
12.0
DescribeAllFileSystems
12.0
ListAllTagsForResource
12.0
CRAP 4.6
1 package Paws::FSX;
2 use Moose;
3 sub service { 'fsx' }
4 sub signing_name { 'fsx' }
5 sub version { '2018-03-01' }
6 sub target_prefix { 'AWSSimbaAPIService_v20180301' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub AssociateFileSystemAliases {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::FSX::AssociateFileSystemAliases', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub CancelDataRepositoryTask {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::FSX::CancelDataRepositoryTask', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CopyBackup {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::FSX::CopyBackup', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateBackup {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::FSX::CreateBackup', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreateDataRepositoryTask {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::FSX::CreateDataRepositoryTask', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub CreateFileSystem {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::FSX::CreateFileSystem', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub CreateFileSystemFromBackup {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::FSX::CreateFileSystemFromBackup', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub DeleteBackup {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::FSX::DeleteBackup', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub DeleteFileSystem {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::FSX::DeleteFileSystem', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub DescribeBackups {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::FSX::DescribeBackups', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub DescribeDataRepositoryTasks {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::FSX::DescribeDataRepositoryTasks', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub DescribeFileSystemAliases {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::FSX::DescribeFileSystemAliases', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub DescribeFileSystems {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::FSX::DescribeFileSystems', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub DisassociateFileSystemAliases {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::FSX::DisassociateFileSystemAliases', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub ListTagsForResource {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::FSX::ListTagsForResource', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub TagResource {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::FSX::TagResource', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub UntagResource {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::FSX::UntagResource', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub UpdateFileSystem {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::FSX::UpdateFileSystem', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108
109 sub DescribeAllBackups {
110 my $self = shift;
111  
112 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
113 my $result = $self->DescribeBackups(@_);
114 my $next_result = $result;
115  
116 if (not defined $callback) {
117 while ($next_result->NextToken) {
118 $next_result = $self->DescribeBackups(@_, NextToken => $next_result->NextToken);
119 push @{ $result->Backups }, @{ $next_result->Backups };
120 }
121 return $result;
122 } else {
123 while ($result->NextToken) {
124 $callback->($_ => 'Backups') foreach (@{ $result->Backups });
125 $result = $self->DescribeBackups(@_, NextToken => $result->NextToken);
126 }
127 $callback->($_ => 'Backups') foreach (@{ $result->Backups });
128 }
129  
130 return undef
131 }
132 sub DescribeAllFileSystems {
133 my $self = shift;
134  
135 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
136 my $result = $self->DescribeFileSystems(@_);
137 my $next_result = $result;
138  
139 if (not defined $callback) {
140 while ($next_result->NextToken) {
141 $next_result = $self->DescribeFileSystems(@_, NextToken => $next_result->NextToken);
142 push @{ $result->FileSystems }, @{ $next_result->FileSystems };
143 }
144 return $result;
145 } else {
146 while ($result->NextToken) {
147 $callback->($_ => 'FileSystems') foreach (@{ $result->FileSystems });
148 $result = $self->DescribeFileSystems(@_, NextToken => $result->NextToken);
149 }
150 $callback->($_ => 'FileSystems') foreach (@{ $result->FileSystems });
151 }
152  
153 return undef
154 }
155 sub ListAllTagsForResource {
156 my $self = shift;
157  
158 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
159 my $result = $self->ListTagsForResource(@_);
160 my $next_result = $result;
161  
162 if (not defined $callback) {
163 while ($next_result->NextToken) {
164 $next_result = $self->ListTagsForResource(@_, NextToken => $next_result->NextToken);
165 push @{ $result->Tags }, @{ $next_result->Tags };
166 }
167 return $result;
168 } else {
169 while ($result->NextToken) {
170 $callback->($_ => 'Tags') foreach (@{ $result->Tags });
171 $result = $self->ListTagsForResource(@_, NextToken => $result->NextToken);
172 }
173 $callback->($_ => 'Tags') foreach (@{ $result->Tags });
174 }
175  
176 return undef
177 }
178  
179  
180 sub operations { qw/AssociateFileSystemAliases CancelDataRepositoryTask CopyBackup CreateBackup CreateDataRepositoryTask CreateFileSystem CreateFileSystemFromBackup DeleteBackup DeleteFileSystem DescribeBackups DescribeDataRepositoryTasks DescribeFileSystemAliases DescribeFileSystems DisassociateFileSystemAliases ListTagsForResource TagResource UntagResource UpdateFileSystem / }
181  
182 1;
183  
184 ### main pod documentation begin ###
185  
186 =head1 NAME
187  
188 Paws::FSX - Perl Interface to AWS Amazon FSx
189  
190 =head1 SYNOPSIS
191  
192 use Paws;
193  
194 my $obj = Paws->service('FSX');
195 my $res = $obj->Method(
196 Arg1 => $val1,
197 Arg2 => [ 'V1', 'V2' ],
198 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
199 # of the arguments type
200 Arg3 => { Att1 => 'Val1' },
201 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
202 # the constructor of the arguments type
203 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
204 );
205  
206 =head1 DESCRIPTION
207  
208 Amazon FSx is a fully managed service that makes it easy for storage
209 and application administrators to launch and use shared file storage.
210  
211 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/fsx-2018-03-01>
212  
213  
214 =head1 METHODS
215  
216 =head2 AssociateFileSystemAliases
217  
218 =over
219  
220 =item Aliases => ArrayRef[Str|Undef]
221  
222 =item FileSystemId => Str
223  
224 =item [ClientRequestToken => Str]
225  
226  
227 =back
228  
229 Each argument is described in detail in: L<Paws::FSX::AssociateFileSystemAliases>
230  
231 Returns: a L<Paws::FSX::AssociateFileSystemAliasesResponse> instance
232  
233 Use this action to associate one or more Domain Name Server (DNS)
234 aliases with an existing Amazon FSx for Windows File Server file
235 system. A file systen can have a maximum of 50 DNS aliases associated
236 with it at any one time. If you try to associate a DNS alias that is
237 already associated with the file system, FSx takes no action on that
238 alias in the request. For more information, see Working with DNS
239 Aliases
240 (https://docs.aws.amazon.com/fsx/latest/WindowsGuide/managing-dns-aliases.html)
241 and Walkthrough 5: Using DNS aliases to access your file system
242 (https://docs.aws.amazon.com/fsx/latest/WindowsGuide/walkthrough05-file-system-custom-CNAME.html),
243 including additional steps you must take to be able to access your file
244 system using a DNS alias.
245  
246 The system response shows the DNS aliases that Amazon FSx is attempting
247 to associate with the file system. Use the API operation to monitor the
248 status of the aliases Amazon FSx is associating with the file system.
249  
250  
251 =head2 CancelDataRepositoryTask
252  
253 =over
254  
255 =item TaskId => Str
256  
257  
258 =back
259  
260 Each argument is described in detail in: L<Paws::FSX::CancelDataRepositoryTask>
261  
262 Returns: a L<Paws::FSX::CancelDataRepositoryTaskResponse> instance
263  
264 Cancels an existing Amazon FSx for Lustre data repository task if that
265 task is in either the C<PENDING> or C<EXECUTING> state. When you cancel
266 a task, Amazon FSx does the following.
267  
268 =over
269  
270 =item *
271  
272 Any files that FSx has already exported are not reverted.
273  
274 =item *
275  
276 FSx continues to export any files that are "in-flight" when the cancel
277 operation is received.
278  
279 =item *
280  
281 FSx does not export any files that have not yet been exported.
282  
283 =back
284  
285  
286  
287 =head2 CopyBackup
288  
289 =over
290  
291 =item SourceBackupId => Str
292  
293 =item [ClientRequestToken => Str]
294  
295 =item [CopyTags => Bool]
296  
297 =item [KmsKeyId => Str]
298  
299 =item [SourceRegion => Str]
300  
301 =item [Tags => ArrayRef[L<Paws::FSX::Tag>]]
302  
303  
304 =back
305  
306 Each argument is described in detail in: L<Paws::FSX::CopyBackup>
307  
308 Returns: a L<Paws::FSX::CopyBackupResponse> instance
309  
310 Copies an existing backup within the same AWS account to another Region
311 (cross-Region copy) or within the same Region (in-Region copy). You can
312 have up to five backup copy requests in progress to a single
313 destination Region per account.
314  
315 You can use cross-Region backup copies for cross-region disaster
316 recovery. You periodically take backups and copy them to another Region
317 so that in the event of a disaster in the primary Region, you can
318 restore from backup and recover availability quickly in the other
319 Region. You can make cross-Region copies only within your AWS
320 partition.
321  
322 You can also use backup copies to clone your file data set to another
323 Region or within the same Region.
324  
325 You can use the C<SourceRegion> parameter to specify the AWS Region
326 from which the backup will be copied. For example, if you make the call
327 from the C<us-west-1> Region and want to copy a backup from the
328 C<us-east-2> Region, you specify C<us-east-2> in the C<SourceRegion>
329 parameter to make a cross-Region copy. If you don't specify a Region,
330 the backup copy is created in the same Region where the request is sent
331 from (in-Region copy).
332  
333 For more information on creating backup copies, see Copying backups
334 (https://docs.aws.amazon.com/fsx/latest/WindowsGuide/using-backups.html#copy-backups)
335 in the I<Amazon FSx for Windows User Guide> and Copying backups
336 (https://docs.aws.amazon.com/fsx/latest/LustreGuide/using-backups-fsx.html#copy-backups)
337 in the I<Amazon FSx for Lustre User Guide>.
338  
339  
340 =head2 CreateBackup
341  
342 =over
343  
344 =item FileSystemId => Str
345  
346 =item [ClientRequestToken => Str]
347  
348 =item [Tags => ArrayRef[L<Paws::FSX::Tag>]]
349  
350  
351 =back
352  
353 Each argument is described in detail in: L<Paws::FSX::CreateBackup>
354  
355 Returns: a L<Paws::FSX::CreateBackupResponse> instance
356  
357 Creates a backup of an existing Amazon FSx file system. Creating
358 regular backups for your file system is a best practice, enabling you
359 to restore a file system from a backup if an issue arises with the
360 original file system.
361  
362 For Amazon FSx for Lustre file systems, you can create a backup only
363 for file systems with the following configuration:
364  
365 =over
366  
367 =item *
368  
369 a Persistent deployment type
370  
371 =item *
372  
373 is I<not> linked to a data respository.
374  
375 =back
376  
377 For more information about backing up Amazon FSx for Lustre file
378 systems, see Working with FSx for Lustre backups
379 (https://docs.aws.amazon.com/fsx/latest/LustreGuide/using-backups-fsx.html).
380  
381 For more information about backing up Amazon FSx for Windows file
382 systems, see Working with FSx for Windows backups
383 (https://docs.aws.amazon.com/fsx/latest/WindowsGuide/using-backups.html).
384  
385 If a backup with the specified client request token exists, and the
386 parameters match, this operation returns the description of the
387 existing backup. If a backup specified client request token exists, and
388 the parameters don't match, this operation returns
389 C<IncompatibleParameterError>. If a backup with the specified client
390 request token doesn't exist, C<CreateBackup> does the following:
391  
392 =over
393  
394 =item *
395  
396 Creates a new Amazon FSx backup with an assigned ID, and an initial
397 lifecycle state of C<CREATING>.
398  
399 =item *
400  
401 Returns the description of the backup.
402  
403 =back
404  
405 By using the idempotent operation, you can retry a C<CreateBackup>
406 operation without the risk of creating an extra backup. This approach
407 can be useful when an initial call fails in a way that makes it unclear
408 whether a backup was created. If you use the same client request token
409 and the initial call created a backup, the operation returns a
410 successful result because all the parameters are the same.
411  
412 The C<CreateBackup> operation returns while the backup's lifecycle
413 state is still C<CREATING>. You can check the backup creation status by
414 calling the DescribeBackups operation, which returns the backup state
415 along with other information.
416  
417  
418 =head2 CreateDataRepositoryTask
419  
420 =over
421  
422 =item FileSystemId => Str
423  
424 =item Report => L<Paws::FSX::CompletionReport>
425  
426 =item Type => Str
427  
428 =item [ClientRequestToken => Str]
429  
430 =item [Paths => ArrayRef[Str|Undef]]
431  
432 =item [Tags => ArrayRef[L<Paws::FSX::Tag>]]
433  
434  
435 =back
436  
437 Each argument is described in detail in: L<Paws::FSX::CreateDataRepositoryTask>
438  
439 Returns: a L<Paws::FSX::CreateDataRepositoryTaskResponse> instance
440  
441 Creates an Amazon FSx for Lustre data repository task. You use data
442 repository tasks to perform bulk operations between your Amazon FSx
443 file system and its linked data repository. An example of a data
444 repository task is exporting any data and metadata changes, including
445 POSIX metadata, to files, directories, and symbolic links (symlinks)
446 from your FSx file system to its linked data repository. A
447 C<CreateDataRepositoryTask> operation will fail if a data repository is
448 not linked to the FSx file system. To learn more about data repository
449 tasks, see Data Repository Tasks
450 (https://docs.aws.amazon.com/fsx/latest/LustreGuide/data-repository-tasks.html).
451 To learn more about linking a data repository to your file system, see
452 Linking your file system to an S3 bucket
453 (https://docs.aws.amazon.com/fsx/latest/LustreGuide/create-fs-linked-data-repo.html).
454  
455  
456 =head2 CreateFileSystem
457  
458 =over
459  
460 =item FileSystemType => Str
461  
462 =item StorageCapacity => Int
463  
464 =item SubnetIds => ArrayRef[Str|Undef]
465  
466 =item [ClientRequestToken => Str]
467  
468 =item [KmsKeyId => Str]
469  
470 =item [LustreConfiguration => L<Paws::FSX::CreateFileSystemLustreConfiguration>]
471  
472 =item [SecurityGroupIds => ArrayRef[Str|Undef]]
473  
474 =item [StorageType => Str]
475  
476 =item [Tags => ArrayRef[L<Paws::FSX::Tag>]]
477  
478 =item [WindowsConfiguration => L<Paws::FSX::CreateFileSystemWindowsConfiguration>]
479  
480  
481 =back
482  
483 Each argument is described in detail in: L<Paws::FSX::CreateFileSystem>
484  
485 Returns: a L<Paws::FSX::CreateFileSystemResponse> instance
486  
487 Creates a new, empty Amazon FSx file system.
488  
489 If a file system with the specified client request token exists and the
490 parameters match, C<CreateFileSystem> returns the description of the
491 existing file system. If a file system specified client request token
492 exists and the parameters don't match, this call returns
493 C<IncompatibleParameterError>. If a file system with the specified
494 client request token doesn't exist, C<CreateFileSystem> does the
495 following:
496  
497 =over
498  
499 =item *
500  
501 Creates a new, empty Amazon FSx file system with an assigned ID, and an
502 initial lifecycle state of C<CREATING>.
503  
504 =item *
505  
506 Returns the description of the file system.
507  
508 =back
509  
510 This operation requires a client request token in the request that
511 Amazon FSx uses to ensure idempotent creation. This means that calling
512 the operation multiple times with the same client request token has no
513 effect. By using the idempotent operation, you can retry a
514 C<CreateFileSystem> operation without the risk of creating an extra
515 file system. This approach can be useful when an initial call fails in
516 a way that makes it unclear whether a file system was created. Examples
517 are if a transport level timeout occurred, or your connection was
518 reset. If you use the same client request token and the initial call
519 created a file system, the client receives success as long as the
520 parameters are the same.
521  
522 The C<CreateFileSystem> call returns while the file system's lifecycle
523 state is still C<CREATING>. You can check the file-system creation
524 status by calling the DescribeFileSystems operation, which returns the
525 file system state along with other information.
526  
527  
528 =head2 CreateFileSystemFromBackup
529  
530 =over
531  
532 =item BackupId => Str
533  
534 =item SubnetIds => ArrayRef[Str|Undef]
535  
536 =item [ClientRequestToken => Str]
537  
538 =item [KmsKeyId => Str]
539  
540 =item [LustreConfiguration => L<Paws::FSX::CreateFileSystemLustreConfiguration>]
541  
542 =item [SecurityGroupIds => ArrayRef[Str|Undef]]
543  
544 =item [StorageType => Str]
545  
546 =item [Tags => ArrayRef[L<Paws::FSX::Tag>]]
547  
548 =item [WindowsConfiguration => L<Paws::FSX::CreateFileSystemWindowsConfiguration>]
549  
550  
551 =back
552  
553 Each argument is described in detail in: L<Paws::FSX::CreateFileSystemFromBackup>
554  
555 Returns: a L<Paws::FSX::CreateFileSystemFromBackupResponse> instance
556  
557 Creates a new Amazon FSx file system from an existing Amazon FSx
558 backup.
559  
560 If a file system with the specified client request token exists and the
561 parameters match, this operation returns the description of the file
562 system. If a client request token specified by the file system exists
563 and the parameters don't match, this call returns
564 C<IncompatibleParameterError>. If a file system with the specified
565 client request token doesn't exist, this operation does the following:
566  
567 =over
568  
569 =item *
570  
571 Creates a new Amazon FSx file system from backup with an assigned ID,
572 and an initial lifecycle state of C<CREATING>.
573  
574 =item *
575  
576 Returns the description of the file system.
577  
578 =back
579  
580 Parameters like Active Directory, default share name, automatic backup,
581 and backup settings default to the parameters of the file system that
582 was backed up, unless overridden. You can explicitly supply other
583 settings.
584  
585 By using the idempotent operation, you can retry a
586 C<CreateFileSystemFromBackup> call without the risk of creating an
587 extra file system. This approach can be useful when an initial call
588 fails in a way that makes it unclear whether a file system was created.
589 Examples are if a transport level timeout occurred, or your connection
590 was reset. If you use the same client request token and the initial
591 call created a file system, the client receives success as long as the
592 parameters are the same.
593  
594 The C<CreateFileSystemFromBackup> call returns while the file system's
595 lifecycle state is still C<CREATING>. You can check the file-system
596 creation status by calling the DescribeFileSystems operation, which
597 returns the file system state along with other information.
598  
599  
600 =head2 DeleteBackup
601  
602 =over
603  
604 =item BackupId => Str
605  
606 =item [ClientRequestToken => Str]
607  
608  
609 =back
610  
611 Each argument is described in detail in: L<Paws::FSX::DeleteBackup>
612  
613 Returns: a L<Paws::FSX::DeleteBackupResponse> instance
614  
615 Deletes an Amazon FSx backup, deleting its contents. After deletion,
616 the backup no longer exists, and its data is gone.
617  
618 The C<DeleteBackup> call returns instantly. The backup will not show up
619 in later C<DescribeBackups> calls.
620  
621 The data in a deleted backup is also deleted and can't be recovered by
622 any means.
623  
624  
625 =head2 DeleteFileSystem
626  
627 =over
628  
629 =item FileSystemId => Str
630  
631 =item [ClientRequestToken => Str]
632  
633 =item [LustreConfiguration => L<Paws::FSX::DeleteFileSystemLustreConfiguration>]
634  
635 =item [WindowsConfiguration => L<Paws::FSX::DeleteFileSystemWindowsConfiguration>]
636  
637  
638 =back
639  
640 Each argument is described in detail in: L<Paws::FSX::DeleteFileSystem>
641  
642 Returns: a L<Paws::FSX::DeleteFileSystemResponse> instance
643  
644 Deletes a file system, deleting its contents. After deletion, the file
645 system no longer exists, and its data is gone. Any existing automatic
646 backups will also be deleted.
647  
648 By default, when you delete an Amazon FSx for Windows File Server file
649 system, a final backup is created upon deletion. This final backup is
650 not subject to the file system's retention policy, and must be manually
651 deleted.
652  
653 The C<DeleteFileSystem> action returns while the file system has the
654 C<DELETING> status. You can check the file system deletion status by
655 calling the DescribeFileSystems action, which returns a list of file
656 systems in your account. If you pass the file system ID for a deleted
657 file system, the DescribeFileSystems returns a C<FileSystemNotFound>
658 error.
659  
660 Deleting an Amazon FSx for Lustre file system will fail with a 400
661 BadRequest if a data repository task is in a C<PENDING> or C<EXECUTING>
662 state.
663  
664 The data in a deleted file system is also deleted and can't be
665 recovered by any means.
666  
667  
668 =head2 DescribeBackups
669  
670 =over
671  
672 =item [BackupIds => ArrayRef[Str|Undef]]
673  
674 =item [Filters => ArrayRef[L<Paws::FSX::Filter>]]
675  
676 =item [MaxResults => Int]
677  
678 =item [NextToken => Str]
679  
680  
681 =back
682  
683 Each argument is described in detail in: L<Paws::FSX::DescribeBackups>
684  
685 Returns: a L<Paws::FSX::DescribeBackupsResponse> instance
686  
687 Returns the description of specific Amazon FSx backups, if a
688 C<BackupIds> value is provided for that backup. Otherwise, it returns
689 all backups owned by your AWS account in the AWS Region of the endpoint
690 that you're calling.
691  
692 When retrieving all backups, you can optionally specify the
693 C<MaxResults> parameter to limit the number of backups in a response.
694 If more backups remain, Amazon FSx returns a C<NextToken> value in the
695 response. In this case, send a later request with the C<NextToken>
696 request parameter set to the value of C<NextToken> from the last
697 response.
698  
699 This action is used in an iterative process to retrieve a list of your
700 backups. C<DescribeBackups> is called first without a
701 C<NextToken>value. Then the action continues to be called with the
702 C<NextToken> parameter set to the value of the last C<NextToken> value
703 until a response has no C<NextToken>.
704  
705 When using this action, keep the following in mind:
706  
707 =over
708  
709 =item *
710  
711 The implementation might return fewer than C<MaxResults> file system
712 descriptions while still including a C<NextToken> value.
713  
714 =item *
715  
716 The order of backups returned in the response of one C<DescribeBackups>
717 call and the order of backups returned across the responses of a
718 multi-call iteration is unspecified.
719  
720 =back
721  
722  
723  
724 =head2 DescribeDataRepositoryTasks
725  
726 =over
727  
728 =item [Filters => ArrayRef[L<Paws::FSX::DataRepositoryTaskFilter>]]
729  
730 =item [MaxResults => Int]
731  
732 =item [NextToken => Str]
733  
734 =item [TaskIds => ArrayRef[Str|Undef]]
735  
736  
737 =back
738  
739 Each argument is described in detail in: L<Paws::FSX::DescribeDataRepositoryTasks>
740  
741 Returns: a L<Paws::FSX::DescribeDataRepositoryTasksResponse> instance
742  
743 Returns the description of specific Amazon FSx for Lustre data
744 repository tasks, if one or more C<TaskIds> values are provided in the
745 request, or if filters are used in the request. You can use filters to
746 narrow the response to include just tasks for specific file systems, or
747 tasks in a specific lifecycle state. Otherwise, it returns all data
748 repository tasks owned by your AWS account in the AWS Region of the
749 endpoint that you're calling.
750  
751 When retrieving all tasks, you can paginate the response by using the
752 optional C<MaxResults> parameter to limit the number of tasks returned
753 in a response. If more tasks remain, Amazon FSx returns a C<NextToken>
754 value in the response. In this case, send a later request with the
755 C<NextToken> request parameter set to the value of C<NextToken> from
756 the last response.
757  
758  
759 =head2 DescribeFileSystemAliases
760  
761 =over
762  
763 =item FileSystemId => Str
764  
765 =item [ClientRequestToken => Str]
766  
767 =item [MaxResults => Int]
768  
769 =item [NextToken => Str]
770  
771  
772 =back
773  
774 Each argument is described in detail in: L<Paws::FSX::DescribeFileSystemAliases>
775  
776 Returns: a L<Paws::FSX::DescribeFileSystemAliasesResponse> instance
777  
778 Returns the DNS aliases that are associated with the specified Amazon
779 FSx for Windows File Server file system. A history of all DNS aliases
780 that have been associated with and disassociated from the file system
781 is available in the list of AdministrativeAction provided in the
782 DescribeFileSystems operation response.
783  
784  
785 =head2 DescribeFileSystems
786  
787 =over
788  
789 =item [FileSystemIds => ArrayRef[Str|Undef]]
790  
791 =item [MaxResults => Int]
792  
793 =item [NextToken => Str]
794  
795  
796 =back
797  
798 Each argument is described in detail in: L<Paws::FSX::DescribeFileSystems>
799  
800 Returns: a L<Paws::FSX::DescribeFileSystemsResponse> instance
801  
802 Returns the description of specific Amazon FSx file systems, if a
803 C<FileSystemIds> value is provided for that file system. Otherwise, it
804 returns descriptions of all file systems owned by your AWS account in
805 the AWS Region of the endpoint that you're calling.
806  
807 When retrieving all file system descriptions, you can optionally
808 specify the C<MaxResults> parameter to limit the number of descriptions
809 in a response. If more file system descriptions remain, Amazon FSx
810 returns a C<NextToken> value in the response. In this case, send a
811 later request with the C<NextToken> request parameter set to the value
812 of C<NextToken> from the last response.
813  
814 This action is used in an iterative process to retrieve a list of your
815 file system descriptions. C<DescribeFileSystems> is called first
816 without a C<NextToken>value. Then the action continues to be called
817 with the C<NextToken> parameter set to the value of the last
818 C<NextToken> value until a response has no C<NextToken>.
819  
820 When using this action, keep the following in mind:
821  
822 =over
823  
824 =item *
825  
826 The implementation might return fewer than C<MaxResults> file system
827 descriptions while still including a C<NextToken> value.
828  
829 =item *
830  
831 The order of file systems returned in the response of one
832 C<DescribeFileSystems> call and the order of file systems returned
833 across the responses of a multicall iteration is unspecified.
834  
835 =back
836  
837  
838  
839 =head2 DisassociateFileSystemAliases
840  
841 =over
842  
843 =item Aliases => ArrayRef[Str|Undef]
844  
845 =item FileSystemId => Str
846  
847 =item [ClientRequestToken => Str]
848  
849  
850 =back
851  
852 Each argument is described in detail in: L<Paws::FSX::DisassociateFileSystemAliases>
853  
854 Returns: a L<Paws::FSX::DisassociateFileSystemAliasesResponse> instance
855  
856 Use this action to disassociate, or remove, one or more Domain Name
857 Service (DNS) aliases from an Amazon FSx for Windows File Server file
858 system. If you attempt to disassociate a DNS alias that is not
859 associated with the file system, Amazon FSx responds with a 400 Bad
860 Request. For more information, see Working with DNS Aliases
861 (https://docs.aws.amazon.com/fsx/latest/WindowsGuide/managing-dns-aliases.html).
862  
863 The system generated response showing the DNS aliases that Amazon FSx
864 is attempting to disassociate from the file system. Use the API
865 operation to monitor the status of the aliases Amazon FSx is
866 disassociating with the file system.
867  
868  
869 =head2 ListTagsForResource
870  
871 =over
872  
873 =item ResourceARN => Str
874  
875 =item [MaxResults => Int]
876  
877 =item [NextToken => Str]
878  
879  
880 =back
881  
882 Each argument is described in detail in: L<Paws::FSX::ListTagsForResource>
883  
884 Returns: a L<Paws::FSX::ListTagsForResourceResponse> instance
885  
886 Lists tags for an Amazon FSx file systems and backups in the case of
887 Amazon FSx for Windows File Server.
888  
889 When retrieving all tags, you can optionally specify the C<MaxResults>
890 parameter to limit the number of tags in a response. If more tags
891 remain, Amazon FSx returns a C<NextToken> value in the response. In
892 this case, send a later request with the C<NextToken> request parameter
893 set to the value of C<NextToken> from the last response.
894  
895 This action is used in an iterative process to retrieve a list of your
896 tags. C<ListTagsForResource> is called first without a
897 C<NextToken>value. Then the action continues to be called with the
898 C<NextToken> parameter set to the value of the last C<NextToken> value
899 until a response has no C<NextToken>.
900  
901 When using this action, keep the following in mind:
902  
903 =over
904  
905 =item *
906  
907 The implementation might return fewer than C<MaxResults> file system
908 descriptions while still including a C<NextToken> value.
909  
910 =item *
911  
912 The order of tags returned in the response of one
913 C<ListTagsForResource> call and the order of tags returned across the
914 responses of a multi-call iteration is unspecified.
915  
916 =back
917  
918  
919  
920 =head2 TagResource
921  
922 =over
923  
924 =item ResourceARN => Str
925  
926 =item Tags => ArrayRef[L<Paws::FSX::Tag>]
927  
928  
929 =back
930  
931 Each argument is described in detail in: L<Paws::FSX::TagResource>
932  
933 Returns: a L<Paws::FSX::TagResourceResponse> instance
934  
935 Tags an Amazon FSx resource.
936  
937  
938 =head2 UntagResource
939  
940 =over
941  
942 =item ResourceARN => Str
943  
944 =item TagKeys => ArrayRef[Str|Undef]
945  
946  
947 =back
948  
949 Each argument is described in detail in: L<Paws::FSX::UntagResource>
950  
951 Returns: a L<Paws::FSX::UntagResourceResponse> instance
952  
953 This action removes a tag from an Amazon FSx resource.
954  
955  
956 =head2 UpdateFileSystem
957  
958 =over
959  
960 =item FileSystemId => Str
961  
962 =item [ClientRequestToken => Str]
963  
964 =item [LustreConfiguration => L<Paws::FSX::UpdateFileSystemLustreConfiguration>]
965  
966 =item [StorageCapacity => Int]
967  
968 =item [WindowsConfiguration => L<Paws::FSX::UpdateFileSystemWindowsConfiguration>]
969  
970  
971 =back
972  
973 Each argument is described in detail in: L<Paws::FSX::UpdateFileSystem>
974  
975 Returns: a L<Paws::FSX::UpdateFileSystemResponse> instance
976  
977 Use this operation to update the configuration of an existing Amazon
978 FSx file system. You can update multiple properties in a single
979 request.
980  
981 For Amazon FSx for Windows File Server file systems, you can update the
982 following properties:
983  
984 =over
985  
986 =item *
987  
988 AuditLogConfiguration
989  
990 =item *
991  
992 AutomaticBackupRetentionDays
993  
994 =item *
995  
996 DailyAutomaticBackupStartTime
997  
998 =item *
999  
1000 SelfManagedActiveDirectoryConfiguration
1001  
1002 =item *
1003  
1004 StorageCapacity
1005  
1006 =item *
1007  
1008 ThroughputCapacity
1009  
1010 =item *
1011  
1012 WeeklyMaintenanceStartTime
1013  
1014 =back
1015  
1016 For Amazon FSx for Lustre file systems, you can update the following
1017 properties:
1018  
1019 =over
1020  
1021 =item *
1022  
1023 AutoImportPolicy
1024  
1025 =item *
1026  
1027 AutomaticBackupRetentionDays
1028  
1029 =item *
1030  
1031 DailyAutomaticBackupStartTime
1032  
1033 =item *
1034  
1035 DataCompressionType
1036  
1037 =item *
1038  
1039 StorageCapacity
1040  
1041 =item *
1042  
1043 WeeklyMaintenanceStartTime
1044  
1045 =back
1046  
1047  
1048  
1049  
1050  
1051 =head1 PAGINATORS
1052  
1053 Paginator methods are helpers that repetively call methods that return partial results
1054  
1055 =head2 DescribeAllBackups(sub { },[BackupIds => ArrayRef[Str|Undef], Filters => ArrayRef[L<Paws::FSX::Filter>], MaxResults => Int, NextToken => Str])
1056  
1057 =head2 DescribeAllBackups([BackupIds => ArrayRef[Str|Undef], Filters => ArrayRef[L<Paws::FSX::Filter>], MaxResults => Int, NextToken => Str])
1058  
1059  
1060 If passed a sub as first parameter, it will call the sub for each element found in :
1061  
1062 - Backups, passing the object as the first parameter, and the string 'Backups' as the second parameter
1063  
1064 If not, it will return a a L<Paws::FSX::DescribeBackupsResponse> 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.
1065  
1066  
1067 =head2 DescribeAllFileSystems(sub { },[FileSystemIds => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
1068  
1069 =head2 DescribeAllFileSystems([FileSystemIds => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
1070  
1071  
1072 If passed a sub as first parameter, it will call the sub for each element found in :
1073  
1074 - FileSystems, passing the object as the first parameter, and the string 'FileSystems' as the second parameter
1075  
1076 If not, it will return a a L<Paws::FSX::DescribeFileSystemsResponse> 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.
1077  
1078  
1079 =head2 ListAllTagsForResource(sub { },ResourceARN => Str, [MaxResults => Int, NextToken => Str])
1080  
1081 =head2 ListAllTagsForResource(ResourceARN => Str, [MaxResults => Int, NextToken => Str])
1082  
1083  
1084 If passed a sub as first parameter, it will call the sub for each element found in :
1085  
1086 - Tags, passing the object as the first parameter, and the string 'Tags' as the second parameter
1087  
1088 If not, it will return a a L<Paws::FSX::ListTagsForResourceResponse> 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.
1089  
1090  
1091  
1092  
1093  
1094 =head1 SEE ALSO
1095  
1096 This service class forms part of L<Paws>
1097  
1098 =head1 BUGS and CONTRIBUTIONS
1099  
1100 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1101  
1102 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1103  
1104 =cut
1105