File Coverage

blib/lib/Jenkins/API.pm

Criterion	Covered	Total	%
statement	73	104	70.1
branch	8	16	50.0
condition	5	9	55.5
subroutine	17	23	73.9
pod	15	15	100.0
total	118	167	70.6

package Jenkins::API;

use Moo;
use Types::Standard -types;
use JSON;
use MIME::Base64;
use URI;
use REST::Client;

# ABSTRACT: A wrapper around the Jenkins API

our $VERSION = '0.16';

has base_url => (is => 'ro', isa => Str, required => 1);
has api_key => (is => 'ro', isa => Maybe[Str], required => 0);
has api_pass => (is => 'ro', isa => Maybe[Str], required => 0);

has '_client' => (
    is      => 'ro',
    lazy    => 1,
    default => sub {
        my $self = shift;
        my $client = REST::Client->new();
        $client->setHost($self->base_url);
        if (defined($self->api_key) and defined($self->api_pass)) {
            $client->addHeader("Authorization", "Basic " .
                               encode_base64($self->api_key . ':' . $self->api_pass));
        }
        return $client;
    }
);


sub create_job
{
    my ($self, $name, $job_config) = @_;

    my $uri = URI->new($self->base_url);
    $uri->path_segments('createItem');
    $uri->query_form( name => $name );
    # curl -XPOST http://moe:8080/createItem?name=test [e-mail] -v -H Content-Type:text/xml
    $self->_client->POST($uri->path_query, $job_config, { 'Content-Type' => 'text/xml' });
    return $self->_client->responseCode() eq '200';
}

sub delete_project
{
    my ($self, $name) = @_;

    my $uri = URI->new($self->base_url);
    $uri->path_segments('job', $name, 'doDelete');
    $self->_client->POST($uri->path_query, undef, { 'Content-Type' => 'text/xml' });
    return $self->_client->responseCode() eq '302';
}

sub trigger_build
{
  my $self = shift;
  return $self->_trigger_build('build', @_);
}

sub trigger_build_with_parameters
{
  my $self = shift;
  return $self->_trigger_build('buildWithParameters', @_);
}

sub _trigger_build
{
    my $self = shift;
    my $build_url = shift;
    my $job = shift;
    my $extra_params = shift;

    my $uri = URI->new($self->base_url);
    $uri->path_segments('job', $job, $build_url);
    $uri->query_form($extra_params) if $extra_params;
    $self->_client->POST($uri->path_query);
    return $self->_client->responseCode eq '201';
}

sub project_config
{
    my $self = shift;
    my $job = shift;
    my $extra_params = shift;

    my $uri = URI->new($self->base_url);
    $uri->path_segments('job', $job, 'config.xml');
    $uri->query_form($extra_params) if $extra_params;
    $self->_client->GET($uri->path_query);
    return $self->_client->responseContent;
}

sub set_project_config
{
    my $self = shift;
    my $job = shift;
    my $config = shift;

    my $uri = URI->new($self->base_url);
    $uri->path_segments('job', $job, 'config.xml');
    $self->_client->POST($uri->path_query, $config, { 'Content-Type' => 'text/xml' });
    return $self->_client->responseCode() eq '200';
}

sub check_jenkins_url
{
    my $self = shift;
    $self->_client->GET('/');
    return $self->_client->responseCode() eq '200'
        && $self->_client->responseHeader('X-Jenkins');
}

sub build_queue
{
    my $self = shift;
    return $self->_json_api(['queue', 'api','json'], @_);
}

sub load_statistics
{
    my $self = shift;
    return $self->_json_api(['overallLoad', 'api','json'], @_);
}

sub get_job_details
{
    my $self = shift;
    my $job_name = shift;
    return $self->_json_api(['job', $job_name, 'api', 'json'], @_);
}

sub current_status
{
    my $self = shift;
    return $self->_json_api(['api','json'], @_);
}

sub view_status
{
    my $self = shift;
    my $view = shift;
    return $self->_json_api(['view', $view, 'api', 'json'], @_);
}

sub _json_api
{
    my $self = shift;
    my $uri_parts = shift;
    my $args = shift;
    my $extra_params = $args->{extra_params};
    my $bits = $args->{path_parts} || [];

    my $uri = URI->new($self->base_url);
    $uri->path_segments(@$bits, @$uri_parts);
    $uri->query_form($extra_params) if $extra_params;

    $self->_client->GET($uri->path_query);
    die 'Invalid response' unless $self->_client->responseCode eq '200';
    # NOTE: my server returns UTF8, if this turns out to be a broken
    # assumption read the Content-Type header.
    my $data = JSON->new->utf8->decode($self->_client->responseContent());
    return $data;
}

sub general_call
{
    my $self = shift;
    my $uri_parts = shift;
    my $args = shift;

    my $extra_params = $args->{extra_params};
    my $method = $args->{method} || 'GET';
    my $decode_json = exists $args->{decode_json} ? $args->{decode_json} : 1;
    my $expected_response = $args->{expected_response_code} || 200;

    my $uri = URI->new($self->base_url);
    $uri->path_segments(@$uri_parts);
    $uri->query_form($extra_params) if $extra_params;

    $self->_client->$method($uri->path_query);
    die 'Invalid response' unless $self->_client->responseCode eq $expected_response;
    my $response = $self->_client->responseContent();
    if($decode_json)
    {
        $response = JSON->new->utf8->decode($response);
    }
    return $response;
}


sub response_code
{
    my $self = shift;
    return $self->_client->responseCode;
}


sub response_content
{
    my $self = shift;
    return $self->_client->responseContent;
}



1; # End of Jenkins::API

__END__