File Coverage

blib/lib/Plack/Middleware/Timeout.pm

Criterion	Covered	Total	%
statement	63	63	100.0
branch	14	16	87.5
condition	1	3	33.3
subroutine	15	15	100.0
pod	2	2	100.0
total	95	99	95.9

package Plack::Middleware::Timeout;

use strict;
use warnings;
use parent 'Plack::Middleware';
use Plack::Util::Accessor qw(timeout response soft_timeout on_soft_timeout);
use Plack::Request;
use Plack::Response;
use Scope::Guard ();
use Time::HiRes qw(alarm time);
use Carp qw(croak);
use HTTP::Status qw(HTTP_GATEWAY_TIMEOUT);

our $VERSION = '0.11';

sub prepare_app {
    my $self = shift;

    $self->timeout(120) unless $self->timeout;

    for my $param (qw(response on_soft_timeout)) {
        next unless defined $self->$param;
        croak "parameter $param isn't a CODE reference!"
          unless ref( $self->$param ) eq 'CODE';
    }
}

my $default_on_soft_timeout = sub {
    warn sprintf "Soft timeout reached for uri '%s' (soft timeout: %ds) request took %ds", @_;
};

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

    my $alarm_msg = 'Plack::Middleware::Timeout';
    local $SIG{ALRM} = sub { die $alarm_msg };

    my $time_started = 0;
    local $@;
    eval {

        $time_started = time();
        alarm($self->timeout);

        my $guard = Scope::Guard->new(sub {
            alarm 0;
        });

        my $soft_timeout_guard;

        if ( my $soft_timeout = $self->soft_timeout ) {
            $soft_timeout_guard = Scope::Guard->new(
                sub {
                    if ( time() - $time_started > $soft_timeout ) {
                        my $on_soft_timeout =
                          $self->on_soft_timeout || $default_on_soft_timeout;

                        my $request = Plack::Request->new($env);

                        $on_soft_timeout->(
                            $request->uri,
                            $soft_timeout,
                        );
                    }
                }
            );
        }

        return $self->app->($env);

    } or do {
        my $error = $@;
        if ( $error =~ /Plack::Middleware::Timeout/ ) {

            my $request = Plack::Request->new($env);
            my $response = Plack::Response->new(HTTP_GATEWAY_TIMEOUT);
            if ( my $build_response_coderef = $self->response ) {
                $build_response_coderef->($response);
            }
            else {
                # warn by default, so there's a trace of the timeout left somewhere
                warn sprintf
                  "Terminated request for uri '%s' due to timeout (%ds)",
                  $request->uri,
                  $self->timeout;
            }

            return $response->finalize;
        } else {
            # something else blew up, so rethrow it
            die $@;
        }
    };
}

1;

__END__