File Coverage

blib/lib/Jenkins/API.pm

Criterion	Covered	Total	%
statement	83	103	80.5
branch	9	16	56.2
condition	5	9	55.5
subroutine	18	22	81.8
pod	13	13	100.0
total	128	163	78.5

package Jenkins::API;

use Moo;
use Types::Standard -types;
use JSON;
use MIME::Base64;
use URI;
use REST::Client;
use HTTP::Status qw(HTTP_CREATED HTTP_FOUND HTTP_OK);

# ABSTRACT: A wrapper around the Jenkins API

our $VERSION = '0.18';

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;
    },
    handles => {
      response_code    => 'responseCode',
      response_content => 'responseContent',
      response_header  => 'responseHeader'
    }
);


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->response_code == HTTP_OK;
}

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->response_code == HTTP_FOUND;
}

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->response_code == HTTP_CREATED;
}

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->response_content;
}

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->response_code == HTTP_OK;
}

sub check_jenkins_url
{
    my $self = shift;
    $self->_client->GET('/');
    return $self->response_code == HTTP_OK
        && $self->response_header('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->response_code == HTTP_OK;
    # 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->response_content());
    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} || HTTP_OK;

    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->response_code == $expected_response;
    my $response = $self->response_content();
    if($decode_json)
    {
        $response = JSON->new->utf8->decode($response);
    }
    return $response;
}





1; # End of Jenkins::API

__END__