blib/lib/POE/Component/Amazon/S3.pm

filter: Statementstmt 92.5% 25 / 27 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 9 / 9 Podpod n/a totaltotal 94.4% 34 / 36 CC 1 SCAR 0.3
CC
1
Cov
93%
BEGIN
1.3
BEGIN
1.0
BEGIN
1.0
CRAP 1.0
↑ Summary
1 package POE::Component::Amazon::S3;
2  
3 5 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 5 ▶use Carp qw(carp croak);
Subroutine BEGIN: called CC=1 SCAR=0.0
6 5 ▶use Data::Dump qw(dump);
Subroutine BEGIN: called CC=1 SCAR=0.0
7 5 ▶use Digest::HMAC_SHA1;
Subroutine BEGIN: called CC=1 SCAR=0.0
8 5 ▶use HTTP::Date;
Subroutine BEGIN: called CC=1 SCAR=0.0
9 5 ▶use HTTP::Request;
Subroutine BEGIN: called CC=1 SCAR=0.0
10 5 ▶use MIME::Base64 qw(encode_base64);
Subroutine BEGIN: called CC=1 SCAR=0.0
11 5 ▶use POE;
Subroutine BEGIN: called CC=1 SCAR=0.0
12 0 ▶use POE::Component::Client::HTTP;
Subroutine BEGIN: called CC=1 SCAR=2.6
13 use URI::Escape qw(uri_escape);
14 use XML::LibXML;
15 use XML::LibXML::XPathContext;
16  
17 our $VERSION = '0.01';
18  
19 my $AMAZON_HEADER_PREFIX = 'x-amz-';
20 my $METADATA_PREFIX = 'x-amz-meta-';
21  
22 # block size when downloading/uploading to files
23 my $BLOCK_SIZE = 4096;
24  
25 # max keys to fetch each time when calling list_bucket_all
26 my $MAX_KEYS_PER_CHUNK = 100;
27  
28 # unique id counter for list_bucket_all to store temporary results
29 my $LIST_ID = 1;
30  
31 sub spawn {
32 my $class = shift;
33
34 croak "$class requires an even number of parameters" if @_ % 2;
35
36 my %params = @_;
37
38 croak "$class requires aws_access_key_id and aws_secret_access_key"
39 unless $params{aws_access_key_id} && $params{aws_secret_access_key};
40
41 $params{libxml} = XML::LibXML->new;
42
43 my $self = bless \%params, $class;
44
45 # A non-streaming HTTP client for most requests
46 POE::Component::Client::HTTP->spawn(
47 Agent => 'POE-Component-Amazon-S3/' . $VERSION,
48 Alias => 'ua',
49 Timeout => 30,
50 );
51
52 # A streaming HTTP client for downloads
53 POE::Component::Client::HTTP->spawn(
54 Agent => 'POE-Component-Amazon-S3/' . $VERSION,
55 Alias => 'ua-streaming',
56 Timeout => 30,
57 Streaming => $BLOCK_SIZE,
58 );
59
60 POE::Session->create(
61 object_states => [
62 $self => [
63 qw/
64 _start
65 shutdown
66
67 add_bucket
68 add_bucket_done
69 buckets
70 buckets_done
71 delete_bucket
72 delete_bucket_done
73  
74 add_key
75 add_key_done
76 head_key
77 head_key_done
78 list_bucket
79 list_bucket_done
80 list_bucket_all
81 list_bucket_all_chunk
82 get_acl
83 get_acl_done
84 get_key
85 get_key_done
86 delete_key
87 delete_key_done
88 set_acl
89 set_acl_got_current
90 set_acl_done
91 /
92 ],
93 ],
94 );
95
96 return;
97 }
98  
99 sub _start {
100 my ( $kernel, $self ) = @_[ KERNEL, OBJECT ];
101
102 $kernel->alias_set( $self->{alias} || 's3' );
103 }
104  
105 sub shutdown {
106 my ( $kernel, $self ) = @_[ KERNEL, OBJECT ];
107
108 # Shut down our HTTP clients
109 $kernel->post( ua => 'shutdown' );
110 $kernel->post( 'ua-streaming' => 'shutdown' );
111
112 $kernel->alias_remove( $self->{alias} || 'amazon-s3' );
113 }
114  
115 ### Bucket methods
116  
117 sub add_bucket {
118 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
119
120 my $bucket = $conf->{bucket};
121 croak 'must specify bucket' unless $bucket;
122  
123 if ($conf->{acl_short}){
124 $self->_validate_acl_short($conf->{acl_short});
125 }
126  
127 my $header_ref = ($conf->{acl_short})
128 ? {'x-amz-acl' => $conf->{acl_short}}
129 : {};
130
131 my $request = $self->_make_request( PUT => $bucket, $header_ref );
132
133 # Save callback info
134 my $pass = {
135 sender => $sender,
136 event => $event,
137 pass => $conf->{pass} || [],
138 };
139
140 $kernel->post( ua => request => add_bucket_done => $request, $pass );
141 }
142  
143 sub add_bucket_done {
144 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
145
146 my $request = $req->[0];
147 my $pass = $req->[1];
148 my $response = $res->[0];
149
150 my $return = $self->_check_error( $response );
151
152 $kernel->post(
153 $pass->{sender},
154 $pass->{event},
155 $return,
156 $response,
157 @{ $pass->{pass} },
158 );
159 }
160  
161 sub buckets {
162 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
163  
164 my $request = $self->_make_request( GET => '' );
165  
166 # Save callback info
167 my $pass = {
168 sender => $sender,
169 event => $event,
170 pass => $conf->{pass} || [],
171 };
172  
173 $kernel->post( ua => request => buckets_done => $request, $pass );
174 }
175  
176 sub buckets_done {
177 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
178  
179 my $request = $req->[0];
180 my $pass = $req->[1];
181 my $response = $res->[0];
182
183 my $return = $self->_check_error( $response );
184
185 if ( $return ) {
186 my $xpc = $self->_xpc_of_content( $response->content );
187
188 my $owner_id = $xpc->findvalue("//s3:Owner/s3:ID");
189 my $owner_displayname = $xpc->findvalue("//s3:Owner/s3:DisplayName");
190  
191 my @buckets;
192 foreach my $node ( $xpc->findnodes(".//s3:Bucket") ) {
193 push @buckets, {
194 bucket => $xpc->findvalue( ".//s3:Name", $node ),
195 creation_date => $xpc->findvalue( ".//s3:CreationDate", $node ),
196 };
197 }
198
199 $return = {
200 owner_id => $owner_id,
201 owner_displayname => $owner_displayname,
202 buckets => \@buckets,
203 };
204 }
205
206 $kernel->post(
207 $pass->{sender},
208 $pass->{event},
209 $return,
210 $response,
211 @{ $pass->{pass} },
212 );
213 }
214  
215 sub delete_bucket {
216 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
217
218 my $bucket = delete $conf->{bucket};
219
220 croak 'must specify bucket' unless $bucket;
221  
222 my $request = $self->_make_request( DELETE => $bucket );
223  
224 # Save callback info
225 my $pass = {
226 sender => $sender,
227 event => $event,
228 pass => $conf->{pass} || [],
229 };
230  
231 $kernel->post( ua => request => delete_bucket_done => $request, $pass );
232 }
233  
234 sub delete_bucket_done {
235 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
236  
237 my $request = $req->[0];
238 my $pass = $req->[1];
239 my $response = $res->[0];
240  
241 my $return = $self->_check_error( $response );
242  
243 $kernel->post(
244 $pass->{sender},
245 $pass->{event},
246 $return,
247 $response,
248 @{ $pass->{pass} },
249 );
250 }
251  
252 ### Key methods
253  
254 sub add_key {
255 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
256
257 my $bucket = delete $conf->{bucket};
258 my $key = delete $conf->{key};
259
260 croak 'must specify bucket' unless $bucket;
261 croak 'must specify key' unless $key;
262
263 if ($conf->{acl_short}) {
264 $self->_validate_acl_short($conf->{acl_short});
265 $conf->{'x-amz-acl'} = delete $conf->{acl_short};
266 }
267  
268 my $data = delete $conf->{data} || '';
269 my $file = delete $conf->{file};
270  
271 my $pass = delete $conf->{pass};
272
273 my $request = $self->_make_request(
274 PUT => $self->_uri( $bucket, $key ), $conf, $data
275 );
276  
277 if ( $file && -e $file ) {
278 # Upload directly from a file
279 $request->content_length( -s $file );
280
281 open my $fh, '<', $file;
282
283 my $file_cb = sub {
284 my $read = sysread $fh, my $buf, $BLOCK_SIZE;
285
286 if ( $read ) {
287 return $buf;
288 }
289 else {
290 close $fh;
291 return '';
292 }
293 };
294
295 $request->content( $file_cb );
296 }
297
298 # Save callback info
299 my $pass = {
300 sender => $sender,
301 event => $event,
302 pass => $pass || [],
303 };
304  
305 $kernel->post( ua => request => add_key_done => $request, $pass );
306 }
307  
308 sub add_key_done {
309 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
310  
311 my $request = $req->[0];
312 my $pass = $req->[1];
313 my $response = $res->[0];
314  
315 my $return = $self->_check_error( $response );
316  
317 $kernel->post(
318 $pass->{sender},
319 $pass->{event},
320 $return,
321 $response,
322 @{ $pass->{pass} }
323 );
324 }
325  
326 sub head_key {
327 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
328
329 my $bucket = delete $conf->{bucket};
330 my $key = delete $conf->{key};
331
332 croak 'must specify bucket' unless $bucket;
333 croak 'must specify key' unless $key;
334
335 my $request = $self->_make_request( HEAD => $self->_uri( $bucket, $key ) );
336
337 # Save callback info
338 my $pass = {
339 sender => $sender,
340 event => $event,
341 pass => $conf->{pass} || [],
342 };
343  
344 $kernel->post( ua => request => head_key_done => $request, $pass );
345 }
346  
347 sub head_key_done {
348 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
349
350 my $request = $req->[0];
351 my $pass = $req->[1];
352 my $response = $res->[0];
353
354 my $return = $self->_check_error( $response );
355
356 $kernel->post(
357 $pass->{sender},
358 $pass->{event},
359 $return,
360 $response,
361 @{ $pass->{pass} },
362 );
363 }
364  
365 sub list_bucket {
366 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
367
368 my $bucket = delete $conf->{bucket};
369 croak 'must specify bucket' unless $bucket;
370
371 my $pass = delete $conf->{pass};
372
373 my $path = $bucket;
374
375 if ( %$conf ) {
376 $path .= '?'
377 . join( '&',
378 map { $_ . '=' . $self->_urlencode( $conf->{$_} ) } keys %$conf );
379 }
380
381 my $request = $self->_make_request( GET => $path );
382
383 # Save callback info
384 my $pass = {
385 sender => $sender,
386 event => $event,
387 pass => $pass || [],
388 conf => $conf,
389 };
390
391 $kernel->post( ua => request => list_bucket_done => $request, $pass );
392 }
393  
394 sub list_bucket_done {
395 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
396
397 my $request = $req->[0];
398 my $pass = $req->[1];
399 my $response = $res->[0];
400
401 my $return = $self->_check_error( $response );
402
403 if ( $return ) {
404 my $xpc = $self->_xpc_of_content( $response->content );
405
406 $return = {
407 bucket => $xpc->findvalue("//s3:ListBucketResult/s3:Name"),
408 prefix => $xpc->findvalue("//s3:ListBucketResult/s3:Prefix"),
409 marker => $xpc->findvalue("//s3:ListBucketResult/s3:Marker"),
410 next_marker => $xpc->findvalue("//s3:ListBucketResult/s3:NextMarker"),
411 max_keys => $xpc->findvalue("//s3:ListBucketResult/s3:MaxKeys"),
412 is_truncated => (
413 scalar $xpc->findvalue("//s3:ListBucketResult/s3:IsTruncated") eq
414 'true'
415 ? 1
416 : 0
417 ),
418 };
419
420 my @keys;
421 foreach my $node ( $xpc->findnodes(".//s3:Contents") ) {
422 my $etag = $xpc->findvalue( ".//s3:ETag", $node );
423 $etag =~ s/^"//;
424 $etag =~ s/"$//;
425  
426 push @keys,
427 {
428 key => $xpc->findvalue( ".//s3:Key", $node ),
429 last_modified => $xpc->findvalue( ".//s3:LastModified", $node ),
430 etag => $etag,
431 size => $xpc->findvalue( ".//s3:Size", $node ),
432 storage_class => $xpc->findvalue( ".//s3:StorageClass", $node ),
433 owner_id => $xpc->findvalue( ".//s3:ID", $node ),
434 owner_displayname =>
435 $xpc->findvalue( ".//s3:DisplayName", $node ),
436 };
437 }
438 $return->{keys} = \@keys;
439
440 if ( my $delimiter = $pass->{conf}->{delimiter} ) {
441 my @common_prefixes;
442 my $strip_delim = qr/$delimiter$/;
443  
444 foreach my $node ( $xpc->findnodes(".//s3:CommonPrefixes") ) {
445 my $prefix = $xpc->findvalue( ".//s3:Prefix", $node );
446  
447 # strip delimiter from end of prefix
448 $prefix =~ s/$strip_delim//;
449  
450 push @common_prefixes, $prefix;
451 }
452 $return->{common_prefixes} = \@common_prefixes;
453 }
454 }
455
456 $kernel->post(
457 $pass->{sender},
458 $pass->{event},
459 $return,
460 $response,
461 @{ $pass->{pass} },
462 );
463 }
464  
465 sub list_bucket_all {
466 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
467
468 my $bucket = $conf->{bucket};
469 croak 'must specify bucket' unless $bucket;
470
471 # Fetch small chunks of 100 from list_bucket and combine them all together
472 $conf->{'max-keys'} = $MAX_KEYS_PER_CHUNK;
473
474 $kernel->yield(
475 list_bucket => 'list_bucket_all_chunk',
476 {
477 %{$conf},
478 pass => [ $sender, $event, $conf, $LIST_ID++ ],
479 },
480 );
481 }
482  
483 sub list_bucket_all_chunk {
484 my ( $kernel, $self, $return, $response, $sender, $event, $conf, $id ) = @_[ KERNEL, OBJECT, ARG0 .. ARG5 ];
485  
486 if ( $return ) {
487 if ( $self->{ "list_results_$id" } ) {
488 push @{ $self->{ "list_results_$id" }->{keys} }, @{ $return->{keys} };
489 }
490 else {
491 $self->{ "list_results_$id" } = $return;
492 }
493
494 if ( $return->{is_truncated} ) {
495 # Fetch the next chunk
496 my $next_marker = $return->{next_marker} || $return->{keys}->[-1]->{key};
497 $conf->{marker} = $next_marker;
498
499 $kernel->yield(
500 list_bucket => 'list_bucket_all_chunk',
501 {
502 %{$conf},
503 pass => [ $sender, $event, $conf, $id ],
504 },
505 );
506
507 return;
508 }
509 else {
510 # All done!
511 $return = delete $self->{ "list_results_$id" };
512
513 delete $return->{is_truncated};
514 delete $return->{next_marker};
515 delete $return->{max_keys};
516 }
517 }
518  
519 $kernel->post(
520 $sender,
521 $event,
522 $return,
523 $response,
524 @{ $conf->{pass} || [] },
525 );
526 }
527  
528 sub get_acl {
529 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
530
531 my $bucket = delete $conf->{bucket};
532 my $key = delete $conf->{key} || '';
533
534 croak 'must specify bucket' unless $bucket;
535 # Key is optional
536
537 my $request = $self->_make_request( GET => $self->_uri( $bucket, $key ) . '?acl' );
538
539 # Save callback info
540 my $pass = {
541 sender => $sender,
542 event => $event,
543 pass => $conf->{pass} || [],
544 };
545  
546 $kernel->post( ua => request => get_acl_done => $request, $pass );
547 }
548  
549 sub get_acl_done {
550 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
551
552 my $request = $req->[0];
553 my $pass = $req->[1];
554 my $response = $res->[0];
555
556 my $return = $self->_check_error( $response );
557
558 if ( $return ) {
559 $return = $self->_parse_acl( $response->content );
560 }
561
562 $kernel->post(
563 $pass->{sender},
564 $pass->{event},
565 $return,
566 $response,
567 @{ $pass->{pass} },
568 );
569 }
570  
571 sub get_key {
572 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
573
574 my $bucket = delete $conf->{bucket};
575 my $key = delete $conf->{key};
576 my $file = delete $conf->{file};
577
578 croak 'must specify bucket' unless $bucket;
579 croak 'must specify key' unless $key;
580
581 my $request = $self->_make_request( GET => $self->_uri( $bucket, $key ) );
582
583 # Save callback info
584 my $pass = {
585 sender => $sender,
586 event => $event,
587 file => $file,
588 pass => $conf->{pass} || [],
589 };
590  
591 $kernel->post( 'ua-streaming' => request => get_key_done => $request, $pass );
592 }
593  
594 sub get_key_done {
595 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
596
597 my $request = $req->[0];
598 my $pass = $req->[1];
599
600 my $response = $res->[0];
601 my $chunk = $res->[1];
602
603 if ( $chunk ) {
604 if ( $pass->{file} && $response->code =~ /^2\d\d$/ ) {
605 # Save chunks to file, only if response is good
606 if ( !$request->{_fh} ) {
607 open my $fh, '>', $pass->{file};
608 $request->{_fh} = $fh;
609 }
610
611 syswrite $request->{_fh}, $chunk;
612 }
613 else {
614 # Save chunks to response object
615 $response->content( $response->content() . $chunk );
616 }
617
618 return;
619 }
620 else {
621 # We're all done
622 if ( $request->{_fh} ) {
623 $request->{_fh}->close();
624 delete $request->{_fh};
625 }
626 }
627
628 my $return = $self->_check_error( $response );
629
630 $kernel->post(
631 $pass->{sender},
632 $pass->{event},
633 $return,
634 $response,
635 @{ $pass->{pass} },
636 );
637 }
638  
639 sub delete_key {
640 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
641
642 my $bucket = delete $conf->{bucket};
643 my $key = delete $conf->{key};
644
645 croak 'must specify bucket' unless $bucket;
646 croak 'must specify key' unless $key;
647
648 my $request = $self->_make_request( DELETE => $self->_uri( $bucket, $key ) );
649  
650 # Save callback info
651 my $pass = {
652 sender => $sender,
653 event => $event,
654 pass => $conf->{pass} || [],
655 };
656  
657 $kernel->post( ua => request => delete_key_done => $request, $pass );
658 }
659  
660 sub delete_key_done {
661 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
662
663 my $request = $req->[0];
664 my $pass = $req->[1];
665 my $response = $res->[0];
666
667 my $return = $self->_check_error( $response );
668  
669 $kernel->post(
670 $pass->{sender},
671 $pass->{event},
672 $return,
673 $response,
674 @{ $pass->{pass} },
675 );
676 }
677  
678 sub set_acl {
679 my ( $kernel, $self, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, SENDER, ARG0, ARG1 ];
680
681 my $bucket = $conf->{bucket};
682
683 croak 'must specify bucket' unless $bucket;
684 # Key is optional
685
686 # set_acl requires that we first fetch the current ACL, so we can get owner information
687 $kernel->yield(
688 get_acl => 'set_acl_got_current',
689 {
690 %{$conf},
691 pass => [ $sender, $event, $conf ],
692 },
693 );
694 }
695  
696 sub set_acl_got_current {
697 my ( $kernel, $self, $return, $response, $sender, $event, $conf ) = @_[ KERNEL, OBJECT, ARG0 .. ARG4 ];
698
699 if ( $return ) {
700 my $bucket = delete $conf->{bucket};
701 my $key = delete $conf->{key} || '';
702 my $acl = delete $conf->{acl};
703 my $acl_short = delete $conf->{acl_short};
704
705 if ( $acl_short ) {
706 $self->_validate_acl_short( $acl_short );
707 $acl = $self->_construct_acl( $return, $acl_short );
708 }
709 else {
710 $acl = $self->_construct_acl( $return, $acl );
711 }
712
713 my $request = $self->_make_request( PUT => $self->_uri( $bucket, $key ) . '?acl', {}, $acl );
714
715 # Save callback info
716 my $pass = {
717 sender => $sender,
718 event => $event,
719 pass => $conf->{pass} || [],
720 };
721  
722 $kernel->post( ua => request => set_acl_done => $request, $pass );
723 }
724 else {
725 # Failed to get current ACL
726 $kernel->post(
727 $sender,
728 $event,
729 $return,
730 $response,
731 @{ $conf->{pass} || [] },
732 );
733 }
734 }
735  
736 sub set_acl_done {
737 my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];
738
739 my $request = $req->[0];
740 my $pass = $req->[1];
741 my $response = $res->[0];
742
743 my $return = $self->_check_error( $response );
744
745 $kernel->post(
746 $pass->{sender},
747 $pass->{event},
748 $return,
749 $response,
750 @{ $pass->{pass} },
751 );
752 }
753  
754 sub _add_auth_header {
755 my ( $self, $headers, $method, $path ) = @_;
756 my $aws_access_key_id = $self->{aws_access_key_id};
757 my $aws_secret_access_key = $self->{aws_secret_access_key};
758  
759 if ( not $headers->header('Date') ) {
760 $headers->header( Date => time2str(time) );
761 }
762 my $canonical_string
763 = $self->_canonical_string( $method, $path, $headers );
764 my $encoded_canonical
765 = $self->_encode( $aws_secret_access_key, $canonical_string );
766 $headers->header(
767 Authorization => "AWS $aws_access_key_id:$encoded_canonical" );
768 }
769  
770 # generate a canonical string for the given parameters. expires is optional and is
771 # only used by query string authentication.
772 sub _canonical_string {
773 my ( $self, $method, $path, $headers, $expires ) = @_;
774 my %interesting_headers = ();
775 while ( my ( $key, $value ) = each %$headers ) {
776 my $lk = lc $key;
777 if ( $lk eq 'content-md5'
778 or $lk eq 'content-type'
779 or $lk eq 'date'
780 or $lk =~ /^$AMAZON_HEADER_PREFIX/ )
781 {
782 $interesting_headers{$lk} = $self->_trim($value);
783 }
784 }
785  
786 # these keys get empty strings if they don't exist
787 $interesting_headers{'content-type'} ||= '';
788 $interesting_headers{'content-md5'} ||= '';
789  
790 # just in case someone used this. it's not necessary in this lib.
791 $interesting_headers{'date'} = ''
792 if $interesting_headers{'x-amz-date'};
793  
794 # if you're using expires for query string auth, then it trumps date
795 # (and x-amz-date)
796 $interesting_headers{'date'} = $expires if $expires;
797  
798 my $buf = "$method\n";
799 foreach my $key ( sort keys %interesting_headers ) {
800 if ( $key =~ /^$AMAZON_HEADER_PREFIX/ ) {
801 $buf .= "$key:$interesting_headers{$key}\n";
802 } else {
803 $buf .= "$interesting_headers{$key}\n";
804 }
805 }
806  
807 # don't include anything after the first ? in the resource...
808 $path =~ /^([^?]*)/;
809 $buf .= '/' . uri_escape( $1, "^A-Za-z0-9\-_.!~*'()/" );
810  
811 # ...unless there is an acl or torrent parameter
812 if ( $path =~ /[&?]acl($|=|&)/ ) {
813 $buf .= '?acl';
814 } elsif ( $path =~ /[&?]torrent($|=|&)/ ) {
815 $buf .= '?torrent';
816 }
817  
818 return $buf;
819 }
820  
821 # Generates the necessary ACL XML:
822 # Given a string (canned ACL)
823 # Given an array ref (list of grants)
824 sub _construct_acl {
825 my ( $self, $current, $acl ) = @_;
826
827 my $owner_perm = {
828 display_name => $current->{owner_display_name},
829 id => $current->{owner_id},
830 permission => 'FULL_CONTROL',
831 };
832  
833 my $canned = {
834 private => [
835 $owner_perm
836 ],
837 'public-read' => [
838 $owner_perm,
839 {
840 URI => 'http://acs.amazonaws.com/groups/global/AllUsers',
841 permission => 'READ',
842 },
843 ],
844 'public-read-write' => [
845 $owner_perm,
846 {
847 URI => 'http://acs.amazonaws.com/groups/global/AllUsers',
848 permission => 'READ',
849 },
850 {
851 URI => 'http://acs.amazonaws.com/groups/global/AllUsers',
852 permission => 'WRITE',
853 },
854 ],
855 'authenticated-read' => [
856 $owner_perm,
857 {
858 URI => 'http://acs.amazonaws.com/groups/global/AuthenticatedUsers',
859 permission => 'READ',
860 },
861 ],
862 };
863
864 # Always include the owner with full control
865 if ( ref $acl ) {
866 unshift @{$acl}, $owner_perm;
867 }
868
869 my $new_acl = {
870 owner_display_name => $current->{owner_display_name},
871 owner_id => $current->{owner_id},
872 grants => ( ref $acl ) ? $acl : $canned->{$acl},
873 };
874
875 return $self->_acl_to_xml( $new_acl );
876 }
877  
878 sub _acl_to_xml {
879 my ( $self, $acl ) = @_;
880
881 my $doc = $self->{libxml}->createDocument(
882 'http://s3.amazonaws.com/doc/2006-03-01/',
883 'AccessControlPolicy',
884 );
885
886 $doc->setEncoding('UTF-8');
887
888 # Add Owner element
889 my $id = $doc->createElement('ID');
890 my $display_name = $doc->createElement('DisplayName');
891
892 $id->appendText( $acl->{owner_id} );
893 $display_name->appendText( $acl->{owner_display_name} );
894
895 my $owner = $doc->createElement('Owner');
896 $owner->appendChild($id);
897 $owner->appendChild($display_name);
898
899 # Add AccessControlList element
900
901 my $acl_list = $doc->createElement('AccessControlList');
902
903 for my $grant ( @{ $acl->{grants} } ) {
904
905 my $grantee = $doc->createElement('Grantee');
906 $grantee->setAttribute( 'xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance' );
907
908 # URI grant
909 if ( $grant->{URI} ) {
910
911 $grantee->setAttribute( 'xsi:type', 'Group' );
912
913 my $uri = $doc->createElement('URI');
914 $uri->appendText( $grant->{URI} );
915
916 $grantee->appendChild($uri);
917 }
918 # Amazon email grant
919 elsif ( $grant->{email} ) {
920
921 $grantee->setAttribute( 'xsi:type', 'AmazonCustomerByEmail' );
922
923 my $email = $doc->createElement('EmailAddress');
924 $email->appendText( $grant->{email} );
925
926 $grantee->appendChild($email);
927 }
928 # Single user grant
929 else {
930
931 $grantee->setAttribute( 'xsi:type', 'CanonicalUser' );
932
933 my $grantee_id = $doc->createElement('ID');
934 $grantee_id->appendText( $grant->{id} );
935
936 my $grantee_name = $doc->createElement('DisplayName');
937 $grantee_name->appendText( $grant->{display_name} );
938
939 $grantee->appendChild($grantee_id);
940 $grantee->appendChild($grantee_name);
941 }
942
943 my $perm = $doc->createElement('Permission');
944 $perm->appendText( $grant->{permission} );
945
946 my $grant_node = $doc->createElement('Grant');
947 $grant_node->appendChild($grantee);
948 $grant_node->appendChild($perm);
949
950 $acl_list->appendChild($grant_node);
951 }
952
953 my $acl_node = $doc->documentElement();
954 $acl_node->appendChild( $owner );
955 $acl_node->appendChild( $acl_list );
956  
957 return $doc->toString();
958 }
959  
960 sub _check_error {
961 my ( $self, $response ) = @_;
962
963 if ( $response->code =~ /^2\d\d$/ ) {
964 return 1;
965 }
966
967 if ( $response->content ) {
968 my $xpc = $self->_xpc_of_content( $response->content );
969  
970 if ( $xpc->findnodes('//Error') ) {
971 $response->{s3_error} = {
972 code => $xpc->findvalue('//Error/Code'),
973 message => $xpc->findvalue('//Error/Message'),
974 };
975 }
976 }
977
978 return 0;
979 }
980  
981 # finds the hmac-sha1 hash of the canonical string and the aws secret access key and then
982 # base64 encodes the result (optionally urlencoding after that).
983 sub _encode {
984 my ( $self, $aws_secret_access_key, $str, $urlencode ) = @_;
985 my $hmac = Digest::HMAC_SHA1->new($aws_secret_access_key);
986 $hmac->add($str);
987 my $b64 = encode_base64( $hmac->digest, '' );
988 if ($urlencode) {
989 return $self->_urlencode($b64);
990 } else {
991 return $b64;
992 }
993 }
994  
995 # make the HTTP::Request object
996 sub _make_request {
997 my ( $self, $method, $path, $headers, $data, $metadata ) = @_;
998 croak 'must specify method' unless $method;
999 croak 'must specify path' unless defined $path;
1000 $headers ||= {};
1001 $data ||= '';
1002 $metadata ||= {};
1003  
1004 my $http_headers = $self->_merge_meta( $headers, $metadata );
1005  
1006 $self->_add_auth_header( $http_headers, $method, $path );
1007 my $protocol = $self->{secure} ? 'https' : 'http';
1008 my $url = "$protocol://s3.amazonaws.com/$path";
1009 my $request = HTTP::Request->new( $method, $url, $http_headers );
1010 $request->content($data);
1011  
1012 return $request;
1013 }
1014  
1015 # generates an HTTP::Headers objects given one hash that represents http
1016 # headers to set and another hash that represents an object's metadata.
1017 sub _merge_meta {
1018 my ( $self, $headers, $metadata ) = @_;
1019 $headers ||= {};
1020 $metadata ||= {};
1021  
1022 my $http_header = HTTP::Headers->new;
1023 while ( my ( $k, $v ) = each %$headers ) {
1024 $http_header->header( $k => $v );
1025 }
1026 while ( my ( $k, $v ) = each %$metadata ) {
1027 $http_header->header( "$METADATA_PREFIX$k" => $v );
1028 }
1029  
1030 return $http_header;
1031 }
1032  
1033 sub _parse_acl {
1034 my $self = shift;
1035
1036 my $xpc = $self->_xpc_of_content( shift );
1037
1038 my @grants;
1039  
1040 for my $grant ( $xpc->findnodes(".//s3:Grant") ) {
1041 my $perm = {
1042 permission => $xpc->findvalue( ".//s3:Permission", $grant ),
1043 };
1044
1045 if ( my $id = $xpc->findvalue( ".//s3:Grantee/s3:ID", $grant ) ) {
1046 $perm->{id} = $id;
1047 $perm->{display_name} = $xpc->findvalue( ".//s3:Grantee/s3:DisplayName", $grant );
1048 }
1049 elsif ( my $uri = $xpc->findvalue( ".//s3:Grantee/s3:URI", $grant ) ) {
1050 $perm->{URI} = $uri;
1051 }
1052 elsif ( my $email = $xpc->findvalue( ".//s3:Grantee/s3:EmailAddress", $grant ) ) {
1053 $perm->{email} = $email;
1054 }
1055
1056 push @grants, $perm;
1057 }
1058
1059 my $acl = {
1060 owner_id => $xpc->findvalue(".//s3:AccessControlPolicy/s3:Owner/s3:ID"),
1061 owner_display_name => $xpc->findvalue(".//s3:AccessControlPolicy/s3:Owner/s3:DisplayName"),
1062 grants => \@grants,
1063 };
1064
1065 return $acl;
1066 }
1067  
1068 sub _trim {
1069 my ( $self, $value ) = @_;
1070 $value =~ s/^\s+//;
1071 $value =~ s/\s+$//;
1072 return $value;
1073 }
1074  
1075 sub _uri {
1076 my ( $self, $bucket, $key ) = @_;
1077 return ($key)
1078 ? $bucket . "/" . $self->_urlencode($key)
1079 : $bucket
1080 ;
1081 }
1082  
1083 sub _urlencode {
1084 my ( $self, $unencoded ) = @_;
1085
1086 # original module did this, but it breaks for i.e. '.'
1087 # return uri_escape( $unencoded, '^A-Za-z0-9_-' );
1088
1089 return uri_escape( $unencoded );
1090 }
1091  
1092 sub _validate_acl_short {
1093 my ( $self, $policy_name ) = @_;
1094  
1095 if ( ! grep( { $policy_name eq $_ }
1096 qw(private public-read public-read-write authenticated-read) ) ){
1097 croak "$policy_name is not a supported canned access policy";
1098 }
1099 }
1100  
1101 sub _xpc_of_content {
1102 my ( $self, $content ) = @_;
1103 my $doc = $self->{libxml}->parse_string($content);
1104  
1105 my $xpc = XML::LibXML::XPathContext->new($doc);
1106 $xpc->registerNs( 's3', 'http://s3.amazonaws.com/doc/2006-03-01/' );
1107  
1108 return $xpc;
1109 }
1110  
1111 1;
1112 __END__
↑ Summary