view release on metacpan or  search on metacpan

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

    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());
        
        $response = $self->{UserAgent}->request($req);
        
        if ($response->is_success) { # note, 500 and 503 are NOT success :D
            $self->_debug_log($response->content);
            my $href = XMLin($response->content, ForceArray => $force_array, KeyAttr => {});
            return $href;
        } else {
            # advice from internal AWS support - most client libraries try 3 times in the face
            # of 500 errors, so ours should too
            # use exponential backoff.
		
            if ($response->code == 500 || $response->code == 503) {
                my $sleep_amount= 2 ** $try * 50 * 1000;
                $self->_debug_log("Doing sleep for: $sleep_amount");
                Time::HiRes::usleep($sleep_amount);
                next;
            }
            die("Got an error: " . $response->as_string());
        }
    }

    # if we fall out of the loop, then we have either a non-500 error or a persistent 500.
	
    my $msg;
    eval {
        my $href = XMLin($response->content);
        $msg = $href->{Error}{Message};
    };
 
    my $error = "ERROR: On calling $params->{Action}: " . $response->status_line;
    $error .= " ($msg)" if $msg;
    croak $error;
}

sub _debug_log {
    my ($self, $msg) = @_;
    return unless $self->{_Debug};
    chomp($msg);
    print {$self->{_Debug}} $msg . "\n\n";
}

sub _escape_params {