| 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__ | ||