File Coverage

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

Criterion	Covered	Total	%
statement	67	67	100.0
branch	13	14	92.8
condition	10	12	83.3
subroutine	16	16	100.0
pod	4	4	100.0
total	110	113	97.3

package WWW::Hetzner::Role::HTTP;

# ABSTRACT: HTTP client role for Hetzner API clients

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

our $VERSION = '0.100';


requires 'token';
requires 'base_url';

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


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


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


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


sub delete {
    my ($self, $path) = @_;
    return $self->_request('DELETE', $path);
}


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


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

    my $url = $self->base_url . $path;

    # Add query params for GET
    if ($method eq 'GET' && $opts{params}) {
        my @pairs;
        for my $k (keys %{$opts{params}}) {
            my $v = $opts{params}{$k};
            next unless defined $v;
            push @pairs, "$k=$v";
        }
        $url .= '?' . join('&', @pairs) if @pairs;
    }

    $log->debug("$method $url");

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

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

    if ($opts{body}) {
        $req_args{content} = encode_json($opts{body});
        $log->debugf("Body: %s", $req_args{content});
    }

    return WWW::Hetzner::HTTPRequest->new(%req_args);
}


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

    $log->debugf("Response: %s", $response->status);

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

    unless ($response->status >= 200 && $response->status < 300) {
        my $error = $data->{error}{message} // $response->status;
        $log->errorf("API error: %s", $error);
        croak "Hetzner API error: $error";
    }

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


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

    croak "No API token configured" unless $self->token;

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


1;

__END__