File Coverage

blib/lib/Plack/App/GitHub/WebHook.pm

Criterion	Covered	Total	%
statement	119	127	93.7
branch	36	40	90.0
condition	27	31	87.1
subroutine	29	33	87.8
pod	1	4	25.0
total	212	235	90.2

package Plack::App::GitHub::WebHook;
use strict;
use warnings;
use v5.10;

use parent 'Plack::Component';
use Plack::Util::Accessor qw(hook events secret access safe logger);
use Plack::Request;
use Plack::Middleware::HTTPExceptions;
use Plack::Middleware::Access;
use Carp qw(croak);
use JSON qw(decode_json);
use Scalar::Util qw(blessed);

our $VERSION = '0.9';

our @GITHUB_IPS = (
    allow => "204.232.175.64/27",
    allow => "192.30.252.0/22",
);

sub github_webhook {
    my $hook = shift;
    if ( !ref $hook ) {
        my $class = Plack::Util::load_class($hook, 'GitHub::WebHook');
        $class = $class->new;
        return sub { $class->call(@_) };
    } elsif ( ref $hook eq 'HASH' ) {
        my ($class, $args) = each %$hook;
        $class = Plack::Util::load_class($class, 'GitHub::WebHook');
        $class = $class->new( ref $args eq 'HASH' ? %$args : @$args );
        return sub { $class->call(@_) };
    } elsif ( blessed $hook and $hook->can('call') ) {
        return sub { $hook->call(@_) };
    } elsif ( (ref $hook // '') ne 'CODE') {
        croak "hook must be a CODE or ARRAY of CODEs";
    }
    $hook;
}

sub to_app {
    my $self = shift;

    my $hook = (ref $self->hook // '') eq 'ARRAY'
             ? $self->hook : [ $self->hook // () ];
    $self->hook([ map { github_webhook($_) } @$hook ]);

    my $app = Plack::Middleware::HTTPExceptions->wrap(
        sub { $self->call_granted($_[0]) }
    );

    if ($self->secret) {
        require Plack::Middleware::HubSignature;
        $app = Plack::Middleware::HubSignature->wrap($app,
            secret => $self->secret
        );
    }

    $self->access('github') unless $self->access;
    $self->access([]) if $self->access eq 'all';
    my @rules = (@GITHUB_IPS, 'deny' => 'all');
    if ( $self->access !~ /^github$/i ) {
        @rules = ();
        foreach (@{$self->access}) {
            if (@rules and $rules[0] eq 'allow' and $_ =~ /^github$/i) {
                push @rules, @GITHUB_IPS[1 .. $#GITHUB_IPS];
            } else {
                push @rules, $_;
            }
        }
    }
    $app = Plack::Middleware::Access->wrap( $app, rules => \@rules );

    $app;
}

sub call_granted {
    my ($self, $env) = @_;

    if ( $env->{REQUEST_METHOD} ne 'POST' ) {
        return [405,['Content-Type'=>'text/plain','Content-Length'=>18],['Method Not Allowed']];
    }

    my $req = Plack::Request->new($env);
    my $event = $env->{'HTTP_X_GITHUB_EVENT'} // '';
    my $delivery = $env->{'HTTP_X_GITHUB_DELIVERY'} // '';
    my $payload;
    my ($status, $message);

    if ( !$self->events or grep { $event eq $_ } @{$self->events} ) {
        $payload = $req->param('payload') || $req->content;
        $payload = eval { decode_json $payload };
    }

    if (!$payload) {
        return [400,['Content-Type'=>'text/plain','Content-Length'=>11],['Bad Request']];
    }

    my $logger = Plack::App::GitHub::WebHook::Logger->new(
        $self->logger || $env->{'psgix.logger'} || sub { }
    );

    if ( $self->receive( [ $payload, $event, $delivery, $logger ], $env->{'psgi.errors'} ) ) {
        ($status, $message) = (200,"OK");
    } else {
        ($status, $message) = (202,"Accepted");
    }

    $message = ucfirst($event)." $message" if $self->events;

    return [
        $status,
        [ 'Content-Type' => 'text/plain', 'Content-Length' => length $message ],
        [ $message ]
    ];
}

sub receive {
    my ($self, $args, $error) = @_;

    foreach my $hook (@{$self->{hook}}) {
        if ( !eval { $hook->(@$args) } || $@ ) {
            if ( $@ ) {
                if ($self->safe) {
                    $error->print($@);
                } else {
                    die Plack::App::GitHub::WebHook::Exception->new( 500, $@ );
                }
            }
            return;
        }
    }

    return scalar @{$self->{hook}};
}

{
    package Plack::App::GitHub::WebHook::Logger;
    use Scalar::Util qw(blessed);
    sub new {
        my $self = bless { logger => $_[1] }, $_[0];
        foreach my $level (qw(debug info warn error fatal)) {
            $self->{$level} = sub { $self->log( $level => $_[0] ) }
        }
        $self;
    }
    sub log {
        my ($self, $level, $message) = @_;
        chomp $message;
        if (blessed $self->{logger}) {
            $self->{logger}->log( level => $level, message => $message );
        } else {
            $self->{logger}->({ level => $level, message => $message });
        }
        1;
    }
    sub debug { $_[0]->log(debug => $_[1]) }
    sub info  { $_[0]->log(info  => $_[1]) }
    sub warn  { $_[0]->log(warn  => $_[1]) }
    sub error { $_[0]->log(error => $_[1]) }
    sub fatal { $_[0]->log(fatal => $_[1]) }
}

{
    package Plack::App::GitHub::WebHook::Exception;
    use overload  '""' => sub { $_[0]->{message} };
    sub new { bless { code => $_[1], message => $_[2] }, $_[0]; }
    sub code { $_[0]->{code} }
}

1;
__END__