File Coverage

blib/lib/WWW/VastAI/Role/HTTP.pm

Criterion	Covered	Total	%
statement	65	69	94.2
branch	13	24	54.1
condition	3	15	20.0
subroutine	16	17	94.1
pod	4	4	100.0
total	101	129	78.2

package WWW::VastAI::Role::HTTP;
our $VERSION = '0.001';
# ABSTRACT: Shared synchronous HTTP client role for Vast.ai API consumers

use Moo::Role;
use Carp qw(croak);
use JSON::MaybeXS qw(decode_json encode_json);
use Log::Any qw($log);
use URI;
use WWW::VastAI::HTTPRequest;
use WWW::VastAI::LWPIO;

requires 'api_key';
requires 'base_url';

has io => (
    is      => 'lazy',
    builder => sub { WWW::VastAI::LWPIO->new },
);

sub get {
    my ($self, $path, %opts) = @_;
    return $self->_request('GET', $path, %opts);
}

sub post {
    my ($self, $path, $body, %opts) = @_;
    return $self->_request('POST', $path, %opts, body => $body);
}

sub put {
    my ($self, $path, $body, %opts) = @_;
    return $self->_request('PUT', $path, %opts, body => $body);
}

sub delete {
    my ($self, $path, $body, %opts) = @_;
    return $self->_request('DELETE', $path, %opts, (defined $body ? (body => $body) : ()));
}

sub _set_auth {
    my ($self, $headers) = @_;
    $headers->{Authorization} = 'Bearer ' . $self->api_key;
}

sub _build_query_uri {
    my ($self, $url, $params) = @_;

    my $uri = URI->new($url);
    for my $name (sort keys %{$params || {}}) {
        my $value = $params->{$name};
        next unless defined $value;
        $value = encode_json($value) if ref $value;
        $uri->query_param($name => $value);
    }

    return $uri->as_string;
}

sub _build_request {
    my ($self, $method, $path, %opts) = @_;

    my $base_url = $opts{base_url} || $self->base_url;
    my $url = $base_url . $path;
    $url = $self->_build_query_uri($url, $opts{params}) if $opts{params};

    my %headers = (
        'Content-Type' => 'application/json',
    );
    $self->_set_auth(\%headers);

    my %args = (
        method  => $method,
        url     => $url,
        headers => \%headers,
    );

    if (exists $opts{body}) {
        $args{content} = encode_json($opts{body});
        $log->debugf('%s %s body=%s', $method, $url, $args{content});
    }
    else {
        $log->debugf('%s %s', $method, $url);
    }

    return WWW::VastAI::HTTPRequest->new(%args);
}

sub _parse_response {
    my ($self, $response, $method, $path) = @_;

    my $content = $response->content;
    my $data;
    if (defined $content && $content =~ /^\s*[\{\[]/) {
        $data = decode_json($content);
    }
    elsif (defined $content && length $content) {
        $data = $content;
    }

    if ($response->status < 200 || $response->status >= 300) {
        my $message = ref $data eq 'HASH'
            ? ($data->{msg} || $data->{message} || $data->{error} || $response->status)
            : (defined $data ? $data : $response->status);
        croak "Vast.ai API error: $message";
    }

    $log->infof('%s %s -> %s', $method, $path, $response->status);
    return $data;
}

sub _request {
    my ($self, $method, $path, %opts) = @_;

    croak "No Vast.ai API key configured" unless $self->api_key;

    my $req = $self->_build_request($method, $path, %opts);
    my $response = $self->io->call($req);
    return $self->_parse_response($response, $method, $path);
}

1;

__END__