view release on metacpan or  search on metacpan

lib/Amazon/SQS/Simple/Base.pm  view on Meta::CPAN

use MIME::Base64;
use URI::Escape;
use XML::Simple;
use HTTP::Date;
use HTTP::Request::Common;
use AWS::Signature4;
use POSIX qw(strftime);
use Encode qw(encode);
use Data::Dumper;
use Time::HiRes;
use VM::EC2::Security::CredentialCache;

use base qw(Exporter);

use constant ({ 
    SQS_VERSION_2012_11_05 => '2012-11-05',
    BASE_ENDPOINT          => 'http://sqs.us-east-1.amazonaws.com',
    DEF_MAX_GET_MSG_SIZE   => 4096, # Messages larger than this size will use a POST request.
    MAX_RETRIES            => 4,
});
                                       

our $DEFAULT_SQS_VERSION = SQS_VERSION_2012_11_05;
our @EXPORT = qw(SQS_VERSION_2012_11_05);
our $URI_SAFE_CHARACTERS = '^A-Za-z0-9-_.~'; # defined by AWS, same as URI::Escape defaults

sub new {
    my $class      = shift;
    my @args = @_;
    if (scalar(@args) >= 2 && $args[0] ne 'UseIAMRole') {
        my $access_key = shift @args;
        my $secret_key = shift @args;
        @args = (AWSAccessKeyId => $access_key,
                 SecretKey => $secret_key, @args);
    }
    my $self = {
        Endpoint         => +BASE_ENDPOINT,
        SignatureVersion => 4,
        Version          => $DEFAULT_SQS_VERSION,
        @args
    };

    if (!defined($self->{UserAgent})) {
        $self->{UserAgent} = LWP::UserAgent->new(keep_alive => 4);
    }

    if (defined($self->{Timeout})) {
        $self->{UserAgent}->timeout($self->{Timeout});
    }

    if (!defined($self->{Region})) {
        $self->{Region} = 'us-east-1';
    }

    $self->{UserAgent}->env_proxy;

    if (!$self->{UseIAMRole} && (!$self->{AWSAccessKeyId} || !$self->{SecretKey})) {
        croak "Missing AWSAccessKey or SecretKey";
    }

    $self = bless($self, $class);
    return $self;
}

sub _api_version {
    my $self = shift;
    return $self->{Version};
}

sub _dispatch {
    my $self         = shift;
    my $params       = shift || {};
    my $force_array  = shift || [];
    my $url          = $self->{Endpoint};
    my $response;
    my $post_body;
    my $post_request = 0;

    $params = {
        Version             => $self->{Version},
        %$params
    };

    if (!$params->{Timestamp} && !$params->{Expires}) {
        $params->{Timestamp} = _timestamp();
    }

    foreach my $try (1..MAX_RETRIES) {	
        
        my $req = HTTP::Request->new(POST => $url);
        $req->header(host => URI->new($url)->host);
        my $now = time;
        my $http_date = strftime('%Y%m%dT%H%M%SZ', gmtime($now));
        my $date = strftime('%Y%m%d', gmtime($now));
        
        $req->protocol('HTTP/1.1');
        $req->header('Date' => $http_date);
        $req->header('x-amz-target', 'AmazonSQSv20121105.' . $params->{Action});
        $req->header('content-type' => 'application/x-www-form-urlencoded;charset=utf-8');

        if ($self->{UseIAMRole}) {
            my $creds = VM::EC2::Security::CredentialCache->get();
            defined($creds) || die("Unable to retrieve IAM role credentials");
            $self->{AWSAccessKeyId} = $creds->accessKeyId;
            $self->{SecretKey} = $creds->secretAccessKey;
            $req->header('x-amz-security-token' => $creds->sessionToken);
        }

        $params->{AWSAccessKeyId} = $self->{AWSAccessKeyId};

        my $escaped_params = $self->_escape_params($params);
        my $payload = join('&', map { $_ . '=' . $escaped_params->{$_} } keys %$escaped_params);
        $req->content($payload);
        $req->header('Content-Length', length($payload));

        my $signer = AWS::Signature4->new(-access_key => $self->{AWSAccessKeyId},
                                          -secret_key => $self->{SecretKey});
        $signer->sign($req);

        $self->_debug_log($req->as_string());