blib/lib/Paws/LakeFormation.pm untested

filter: Statementstmt 0.0% 0 / 84 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 30 Podpod 0.0% 0 / 29 totaltotal 0.0% 0 / 143 CC 1 SCAR 6.9
CC
1
Cov
0%
service
2.0
signing_name
2.0
version
2.0
CRAP 2.0
1 package Paws::LakeFormation;
2 use Moose;
3 sub service { 'lakeformation' }
4 sub signing_name { 'lakeformation' }
5 sub version { '2017-03-31' }
6 sub target_prefix { 'AWSLakeFormation' }
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 AddLFTagsToResource {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::LakeFormation::AddLFTagsToResource', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub BatchGrantPermissions {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::LakeFormation::BatchGrantPermissions', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub BatchRevokePermissions {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::LakeFormation::BatchRevokePermissions', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateLFTag {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::LakeFormation::CreateLFTag', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub DeleteLFTag {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::LakeFormation::DeleteLFTag', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub DeregisterResource {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::LakeFormation::DeregisterResource', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DescribeResource {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::LakeFormation::DescribeResource', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub GetDataLakeSettings {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::LakeFormation::GetDataLakeSettings', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub GetEffectivePermissionsForPath {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::LakeFormation::GetEffectivePermissionsForPath', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub GetLFTag {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::LakeFormation::GetLFTag', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub GetResourceLFTags {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::LakeFormation::GetResourceLFTags', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub GrantPermissions {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::LakeFormation::GrantPermissions', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub ListLFTags {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::LakeFormation::ListLFTags', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub ListPermissions {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::LakeFormation::ListPermissions', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub ListResources {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::LakeFormation::ListResources', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub PutDataLakeSettings {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::LakeFormation::PutDataLakeSettings', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub RegisterResource {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::LakeFormation::RegisterResource', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub RemoveLFTagsFromResource {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::LakeFormation::RemoveLFTagsFromResource', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub RevokePermissions {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::LakeFormation::RevokePermissions', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub SearchDatabasesByLFTags {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::LakeFormation::SearchDatabasesByLFTags', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub SearchTablesByLFTags {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::LakeFormation::SearchTablesByLFTags', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub UpdateLFTag {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::LakeFormation::UpdateLFTag', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub UpdateResource {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::LakeFormation::UpdateResource', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133
134  
135  
136 sub operations { qw/AddLFTagsToResource BatchGrantPermissions BatchRevokePermissions CreateLFTag DeleteLFTag DeregisterResource DescribeResource GetDataLakeSettings GetEffectivePermissionsForPath GetLFTag GetResourceLFTags GrantPermissions ListLFTags ListPermissions ListResources PutDataLakeSettings RegisterResource RemoveLFTagsFromResource RevokePermissions SearchDatabasesByLFTags SearchTablesByLFTags UpdateLFTag UpdateResource / }
137  
138 1;
139  
140 ### main pod documentation begin ###
141  
142 =head1 NAME
143  
144 Paws::LakeFormation - Perl Interface to AWS AWS Lake Formation
145  
146 =head1 SYNOPSIS
147  
148 use Paws;
149  
150 my $obj = Paws->service('LakeFormation');
151 my $res = $obj->Method(
152 Arg1 => $val1,
153 Arg2 => [ 'V1', 'V2' ],
154 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
155 # of the arguments type
156 Arg3 => { Att1 => 'Val1' },
157 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
158 # the constructor of the arguments type
159 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
160 );
161  
162 =head1 DESCRIPTION
163  
164 AWS Lake Formation
165  
166 Defines the public endpoint for the AWS Lake Formation service.
167  
168 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/lakeformation-2017-03-31>
169  
170  
171 =head1 METHODS
172  
173 =head2 AddLFTagsToResource
174  
175 =over
176  
177 =item LFTags => ArrayRef[L<Paws::LakeFormation::LFTagPair>]
178  
179 =item Resource => L<Paws::LakeFormation::Resource>
180  
181 =item [CatalogId => Str]
182  
183  
184 =back
185  
186 Each argument is described in detail in: L<Paws::LakeFormation::AddLFTagsToResource>
187  
188 Returns: a L<Paws::LakeFormation::AddLFTagsToResourceResponse> instance
189  
190 Attaches one or more tags to an existing resource.
191  
192  
193 =head2 BatchGrantPermissions
194  
195 =over
196  
197 =item Entries => ArrayRef[L<Paws::LakeFormation::BatchPermissionsRequestEntry>]
198  
199 =item [CatalogId => Str]
200  
201  
202 =back
203  
204 Each argument is described in detail in: L<Paws::LakeFormation::BatchGrantPermissions>
205  
206 Returns: a L<Paws::LakeFormation::BatchGrantPermissionsResponse> instance
207  
208 Batch operation to grant permissions to the principal.
209  
210  
211 =head2 BatchRevokePermissions
212  
213 =over
214  
215 =item Entries => ArrayRef[L<Paws::LakeFormation::BatchPermissionsRequestEntry>]
216  
217 =item [CatalogId => Str]
218  
219  
220 =back
221  
222 Each argument is described in detail in: L<Paws::LakeFormation::BatchRevokePermissions>
223  
224 Returns: a L<Paws::LakeFormation::BatchRevokePermissionsResponse> instance
225  
226 Batch operation to revoke permissions from the principal.
227  
228  
229 =head2 CreateLFTag
230  
231 =over
232  
233 =item TagKey => Str
234  
235 =item TagValues => ArrayRef[Str|Undef]
236  
237 =item [CatalogId => Str]
238  
239  
240 =back
241  
242 Each argument is described in detail in: L<Paws::LakeFormation::CreateLFTag>
243  
244 Returns: a L<Paws::LakeFormation::CreateLFTagResponse> instance
245  
246 Creates a tag with the specified name and values.
247  
248  
249 =head2 DeleteLFTag
250  
251 =over
252  
253 =item TagKey => Str
254  
255 =item [CatalogId => Str]
256  
257  
258 =back
259  
260 Each argument is described in detail in: L<Paws::LakeFormation::DeleteLFTag>
261  
262 Returns: a L<Paws::LakeFormation::DeleteLFTagResponse> instance
263  
264 Deletes the specified tag key name. If the attribute key does not exist
265 or the tag does not exist, then the operation will not do anything. If
266 the attribute key exists, then the operation checks if any resources
267 are tagged with this attribute key, if yes, the API throws a 400
268 Exception with the message "Delete not allowed" as the tag key is still
269 attached with resources. You can consider untagging resources with this
270 tag key.
271  
272  
273 =head2 DeregisterResource
274  
275 =over
276  
277 =item ResourceArn => Str
278  
279  
280 =back
281  
282 Each argument is described in detail in: L<Paws::LakeFormation::DeregisterResource>
283  
284 Returns: a L<Paws::LakeFormation::DeregisterResourceResponse> instance
285  
286 Deregisters the resource as managed by the Data Catalog.
287  
288 When you deregister a path, Lake Formation removes the path from the
289 inline policy attached to your service-linked role.
290  
291  
292 =head2 DescribeResource
293  
294 =over
295  
296 =item ResourceArn => Str
297  
298  
299 =back
300  
301 Each argument is described in detail in: L<Paws::LakeFormation::DescribeResource>
302  
303 Returns: a L<Paws::LakeFormation::DescribeResourceResponse> instance
304  
305 Retrieves the current data access role for the given resource
306 registered in AWS Lake Formation.
307  
308  
309 =head2 GetDataLakeSettings
310  
311 =over
312  
313 =item [CatalogId => Str]
314  
315  
316 =back
317  
318 Each argument is described in detail in: L<Paws::LakeFormation::GetDataLakeSettings>
319  
320 Returns: a L<Paws::LakeFormation::GetDataLakeSettingsResponse> instance
321  
322 Retrieves the list of the data lake administrators of a Lake
323 Formation-managed data lake.
324  
325  
326 =head2 GetEffectivePermissionsForPath
327  
328 =over
329  
330 =item ResourceArn => Str
331  
332 =item [CatalogId => Str]
333  
334 =item [MaxResults => Int]
335  
336 =item [NextToken => Str]
337  
338  
339 =back
340  
341 Each argument is described in detail in: L<Paws::LakeFormation::GetEffectivePermissionsForPath>
342  
343 Returns: a L<Paws::LakeFormation::GetEffectivePermissionsForPathResponse> instance
344  
345 Returns the Lake Formation permissions for a specified table or
346 database resource located at a path in Amazon S3.
347 C<GetEffectivePermissionsForPath> will not return databases and tables
348 if the catalog is encrypted.
349  
350  
351 =head2 GetLFTag
352  
353 =over
354  
355 =item TagKey => Str
356  
357 =item [CatalogId => Str]
358  
359  
360 =back
361  
362 Each argument is described in detail in: L<Paws::LakeFormation::GetLFTag>
363  
364 Returns: a L<Paws::LakeFormation::GetLFTagResponse> instance
365  
366 Returns a tag definition.
367  
368  
369 =head2 GetResourceLFTags
370  
371 =over
372  
373 =item Resource => L<Paws::LakeFormation::Resource>
374  
375 =item [CatalogId => Str]
376  
377 =item [ShowAssignedLFTags => Bool]
378  
379  
380 =back
381  
382 Each argument is described in detail in: L<Paws::LakeFormation::GetResourceLFTags>
383  
384 Returns: a L<Paws::LakeFormation::GetResourceLFTagsResponse> instance
385  
386 Returns the tags applied to a resource.
387  
388  
389 =head2 GrantPermissions
390  
391 =over
392  
393 =item Permissions => ArrayRef[Str|Undef]
394  
395 =item Principal => L<Paws::LakeFormation::DataLakePrincipal>
396  
397 =item Resource => L<Paws::LakeFormation::Resource>
398  
399 =item [CatalogId => Str]
400  
401 =item [PermissionsWithGrantOption => ArrayRef[Str|Undef]]
402  
403  
404 =back
405  
406 Each argument is described in detail in: L<Paws::LakeFormation::GrantPermissions>
407  
408 Returns: a L<Paws::LakeFormation::GrantPermissionsResponse> instance
409  
410 Grants permissions to the principal to access metadata in the Data
411 Catalog and data organized in underlying data storage such as Amazon
412 S3.
413  
414 For information about permissions, see Security and Access Control to
415 Metadata and Data
416 (https://docs-aws.amazon.com/lake-formation/latest/dg/security-data-access.html).
417  
418  
419 =head2 ListLFTags
420  
421 =over
422  
423 =item [CatalogId => Str]
424  
425 =item [MaxResults => Int]
426  
427 =item [NextToken => Str]
428  
429 =item [ResourceShareType => Str]
430  
431  
432 =back
433  
434 Each argument is described in detail in: L<Paws::LakeFormation::ListLFTags>
435  
436 Returns: a L<Paws::LakeFormation::ListLFTagsResponse> instance
437  
438 Lists tags that the requester has permission to view.
439  
440  
441 =head2 ListPermissions
442  
443 =over
444  
445 =item [CatalogId => Str]
446  
447 =item [MaxResults => Int]
448  
449 =item [NextToken => Str]
450  
451 =item [Principal => L<Paws::LakeFormation::DataLakePrincipal>]
452  
453 =item [Resource => L<Paws::LakeFormation::Resource>]
454  
455 =item [ResourceType => Str]
456  
457  
458 =back
459  
460 Each argument is described in detail in: L<Paws::LakeFormation::ListPermissions>
461  
462 Returns: a L<Paws::LakeFormation::ListPermissionsResponse> instance
463  
464 Returns a list of the principal permissions on the resource, filtered
465 by the permissions of the caller. For example, if you are granted an
466 ALTER permission, you are able to see only the principal permissions
467 for ALTER.
468  
469 This operation returns only those permissions that have been explicitly
470 granted.
471  
472 For information about permissions, see Security and Access Control to
473 Metadata and Data
474 (https://docs-aws.amazon.com/lake-formation/latest/dg/security-data-access.html).
475  
476  
477 =head2 ListResources
478  
479 =over
480  
481 =item [FilterConditionList => ArrayRef[L<Paws::LakeFormation::FilterCondition>]]
482  
483 =item [MaxResults => Int]
484  
485 =item [NextToken => Str]
486  
487  
488 =back
489  
490 Each argument is described in detail in: L<Paws::LakeFormation::ListResources>
491  
492 Returns: a L<Paws::LakeFormation::ListResourcesResponse> instance
493  
494 Lists the resources registered to be managed by the Data Catalog.
495  
496  
497 =head2 PutDataLakeSettings
498  
499 =over
500  
501 =item DataLakeSettings => L<Paws::LakeFormation::DataLakeSettings>
502  
503 =item [CatalogId => Str]
504  
505  
506 =back
507  
508 Each argument is described in detail in: L<Paws::LakeFormation::PutDataLakeSettings>
509  
510 Returns: a L<Paws::LakeFormation::PutDataLakeSettingsResponse> instance
511  
512 Sets the list of data lake administrators who have admin privileges on
513 all resources managed by Lake Formation. For more information on admin
514 privileges, see Granting Lake Formation Permissions
515 (https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html).
516  
517 This API replaces the current list of data lake admins with the new
518 list being passed. To add an admin, fetch the current list and add the
519 new admin to that list and pass that list in this API.
520  
521  
522 =head2 RegisterResource
523  
524 =over
525  
526 =item ResourceArn => Str
527  
528 =item [RoleArn => Str]
529  
530 =item [UseServiceLinkedRole => Bool]
531  
532  
533 =back
534  
535 Each argument is described in detail in: L<Paws::LakeFormation::RegisterResource>
536  
537 Returns: a L<Paws::LakeFormation::RegisterResourceResponse> instance
538  
539 Registers the resource as managed by the Data Catalog.
540  
541 To add or update data, Lake Formation needs read/write access to the
542 chosen Amazon S3 path. Choose a role that you know has permission to do
543 this, or choose the AWSServiceRoleForLakeFormationDataAccess
544 service-linked role. When you register the first Amazon S3 path, the
545 service-linked role and a new inline policy are created on your behalf.
546 Lake Formation adds the first path to the inline policy and attaches it
547 to the service-linked role. When you register subsequent paths, Lake
548 Formation adds the path to the existing policy.
549  
550 The following request registers a new location and gives AWS Lake
551 Formation permission to use the service-linked role to access that
552 location.
553  
554 C<ResourceArn = arn:aws:s3:::my-bucket UseServiceLinkedRole = true>
555  
556 If C<UseServiceLinkedRole> is not set to true, you must provide or set
557 the C<RoleArn>:
558  
559 C<arn:aws:iam::12345:role/my-data-access-role>
560  
561  
562 =head2 RemoveLFTagsFromResource
563  
564 =over
565  
566 =item LFTags => ArrayRef[L<Paws::LakeFormation::LFTagPair>]
567  
568 =item Resource => L<Paws::LakeFormation::Resource>
569  
570 =item [CatalogId => Str]
571  
572  
573 =back
574  
575 Each argument is described in detail in: L<Paws::LakeFormation::RemoveLFTagsFromResource>
576  
577 Returns: a L<Paws::LakeFormation::RemoveLFTagsFromResourceResponse> instance
578  
579 Removes a tag from the resource. Only database, table, or
580 tableWithColumns resource are allowed. To tag columns, use the column
581 inclusion list in C<tableWithColumns> to specify column input.
582  
583  
584 =head2 RevokePermissions
585  
586 =over
587  
588 =item Permissions => ArrayRef[Str|Undef]
589  
590 =item Principal => L<Paws::LakeFormation::DataLakePrincipal>
591  
592 =item Resource => L<Paws::LakeFormation::Resource>
593  
594 =item [CatalogId => Str]
595  
596 =item [PermissionsWithGrantOption => ArrayRef[Str|Undef]]
597  
598  
599 =back
600  
601 Each argument is described in detail in: L<Paws::LakeFormation::RevokePermissions>
602  
603 Returns: a L<Paws::LakeFormation::RevokePermissionsResponse> instance
604  
605 Revokes permissions to the principal to access metadata in the Data
606 Catalog and data organized in underlying data storage such as Amazon
607 S3.
608  
609  
610 =head2 SearchDatabasesByLFTags
611  
612 =over
613  
614 =item Expression => ArrayRef[L<Paws::LakeFormation::LFTag>]
615  
616 =item [CatalogId => Str]
617  
618 =item [MaxResults => Int]
619  
620 =item [NextToken => Str]
621  
622  
623 =back
624  
625 Each argument is described in detail in: L<Paws::LakeFormation::SearchDatabasesByLFTags>
626  
627 Returns: a L<Paws::LakeFormation::SearchDatabasesByLFTagsResponse> instance
628  
629 This operation allows a search on C<DATABASE> resources by
630 C<TagCondition>. This operation is used by admins who want to grant
631 user permissions on certain C<TagConditions>. Before making a grant,
632 the admin can use C<SearchDatabasesByTags> to find all resources where
633 the given C<TagConditions> are valid to verify whether the returned
634 resources can be shared.
635  
636  
637 =head2 SearchTablesByLFTags
638  
639 =over
640  
641 =item Expression => ArrayRef[L<Paws::LakeFormation::LFTag>]
642  
643 =item [CatalogId => Str]
644  
645 =item [MaxResults => Int]
646  
647 =item [NextToken => Str]
648  
649  
650 =back
651  
652 Each argument is described in detail in: L<Paws::LakeFormation::SearchTablesByLFTags>
653  
654 Returns: a L<Paws::LakeFormation::SearchTablesByLFTagsResponse> instance
655  
656 This operation allows a search on C<TABLE> resources by C<LFTag>s. This
657 will be used by admins who want to grant user permissions on certain
658 LFTags. Before making a grant, the admin can use
659 C<SearchTablesByLFTags> to find all resources where the given C<LFTag>s
660 are valid to verify whether the returned resources can be shared.
661  
662  
663 =head2 UpdateLFTag
664  
665 =over
666  
667 =item TagKey => Str
668  
669 =item [CatalogId => Str]
670  
671 =item [TagValuesToAdd => ArrayRef[Str|Undef]]
672  
673 =item [TagValuesToDelete => ArrayRef[Str|Undef]]
674  
675  
676 =back
677  
678 Each argument is described in detail in: L<Paws::LakeFormation::UpdateLFTag>
679  
680 Returns: a L<Paws::LakeFormation::UpdateLFTagResponse> instance
681  
682 Updates the list of possible values for the specified tag key. If the
683 tag does not exist, the operation throws an EntityNotFoundException.
684 The values in the delete key values will be deleted from list of
685 possible values. If any value in the delete key values is attached to a
686 resource, then API errors out with a 400 Exception - "Update not
687 allowed". Untag the attribute before deleting the tag key's value.
688  
689  
690 =head2 UpdateResource
691  
692 =over
693  
694 =item ResourceArn => Str
695  
696 =item RoleArn => Str
697  
698  
699 =back
700  
701 Each argument is described in detail in: L<Paws::LakeFormation::UpdateResource>
702  
703 Returns: a L<Paws::LakeFormation::UpdateResourceResponse> instance
704  
705 Updates the data access role used for vending access to the given
706 (registered) resource in AWS Lake Formation.
707  
708  
709  
710  
711 =head1 PAGINATORS
712  
713 Paginator methods are helpers that repetively call methods that return partial results
714  
715  
716  
717  
718 =head1 SEE ALSO
719  
720 This service class forms part of L<Paws>
721  
722 =head1 BUGS and CONTRIBUTIONS
723  
724 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
725  
726 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
727  
728 =cut
729