File Coverage

blib/lib/VM/JiffyBox.pm

Criterion	Covered	Total	%
statement	38	107	35.5
branch	8	36	22.2
condition	7	14	50.0
subroutine	10	16	62.5
pod	8	9	88.8
total	71	182	39.0

package VM::JiffyBox;
$VM::JiffyBox::VERSION = '0.03'; # TRIAL
# The line below is recognised by Dist::Zilla and taken for CPAN packaging
# ABSTRACT: OO-API for JiffyBox Virtual Machine

use strict;
use warnings;

use Moo;
use JSON;
use LWP::UserAgent;
use Scalar::Util qw( reftype );

use VM::JiffyBox::Box;

has domain_name => (is => 'rw', default => sub {'https://api.jiffybox.de'});
has version     => (is => 'rw', default => sub {'v1.0'});
has token       => (is => 'rw', required => 1);

has ua          => (is => 'rw', default => sub {LWP::UserAgent->new()});

has test_mode   => (is => 'rw', default => sub {'0'});

# should always keep the last message from the server
has last          => (is => 'rw');
has details_cache => (is => 'rw');

sub base_url {
    my $self = shift;

    return   $self->domain_name . '/'
           . $self->token       . '/'
           . $self->version     ;
}

sub get_details {
    my $self = shift;

    my $url = $self->base_url . '/jiffyBoxes';

    my $response = $self->ua->get($url);

    # POSSIBLE EXIT
    unless ($response->is_success) {
        $self->last ($response->status_line);
        return;
    }

    my $details = from_json($response->decoded_content);

    $self->last         ( $details );
    $self->details_cache( $details );

    return $details;
}

sub get_id_from_name {
    my $self     = shift;
    my $box_name = shift || die 'box_name as argument needed';

    my $details = $self->get_details;

    # EXIT if no details
    return unless $details;

    $self->last         ( $details );

    # EXIT if no expected result
    return unless (reftype $details eq 'HASH');
    return unless (exists $details->{result});
    return unless (reftype $details->{result} eq 'HASH');

    $self->details_cache( $details );

    # look for a match in the results
    foreach my $box (values %{$details->{result}}) {

        # EXIT if no expected result
        return unless (reftype $box eq 'HASH');

        return $box->{id} if ($box->{name} eq $box_name);
    }

    # if we reach here, this means there was no match
    return;
}

sub get_vm {
    my $self   = shift;
    my $box_id = shift || die 'box_id needed';

    my $box = VM::JiffyBox::Box->new(id => $box_id, hypervisor => $self);

    return $box;
}

sub create_vm {
    my $self = shift;
    my $args = {@_};

    # POSSIBLE EXIT (DIE)
    die 'name needed'                     unless $args->{name};
    die 'planid needed'                   unless $args->{planid};
    die 'backupid or distribution needed' unless $args->{backupid}
                                             xor $args->{distribution};

    my $url = $self->base_url . '/jiffyBoxes';

    # transform args into JSON and pass them to API server
    my $response = $self->ua->post($url, Content => to_json($args));

    # POSSIBLE EXIT
    unless ($response->is_success) {
        $self->last ($response->status_line);
        return;
    }

    $self->last(from_json($response->decoded_content));

    # POSSIBLE EXIT
    # TODO: should check the array for more messages
    if (exists $self->last->{messages}->[0]->{type}
        and    $self->last->{messages}->[0]->{type} eq 'error') {
        return;
    }

    my $box_id = $self->last->{result}->{id};
    my $box = VM::JiffyBox::Box->new(id => $box_id, hypervisor => $self, name => $args->{name});

    return $box;
}

sub get_vms {
    my ($self) = shift;

    my $url      = $self->base_url . '/jiffyBoxes';
    my $response = $self->ua->get( $url );

    unless ( $response->is_success ) {
        $self->last ($response->status_line);
        return;
    }

    $self->last( from_json( $response->decoded_content ) );

    if (exists $self->last->{messages}->[0]->{type}
        and    $self->last->{messages}->[0]->{type} eq 'error') {
        return;
    }

    my @boxes;

    my $result = $self->last->{result};
    for my $box_id ( keys %{ $result || {} } ) {
        my $name = $result->{$box_id}->{name};

        push @boxes, VM::JiffyBox::Box->new(
            id         => $box_id,
            name       => $name,
            hypervisor => $self,
        );
    }

    return @boxes;
}

sub get_distributions {
    my ($self) = shift;

    my $url      = $self->base_url . '/distributions';
    my $response = $self->ua->get( $url );

    unless ( $response->is_success ) {
        $self->last ($response->status_line);
        return;
    }

    $self->last( from_json( $response->decoded_content ) );

    return $self->last;
}

sub get_plans {
    my ($self) = shift;

    my $url      = $self->base_url . '/plans';
    my $response = $self->ua->get( $url );

    unless ( $response->is_success ) {
        $self->last ($response->status_line);
        return;
    }

    $self->last( from_json( $response->decoded_content ) );

    return $self->last;
}

sub get_plan_details {
    my ($self, $id_or_name) = @_;

    my $url      = $self->base_url . '/plans/' . $id_or_name;
    my $response = $self->ua->get( $url );

    unless ( $response->is_success ) {
        $self->last ($response->status_line);
        return;
    }

    $self->last( from_json( $response->decoded_content ) );

    return $self->last;
}

1;

__END__