File Coverage

blib/lib/Plack/Middleware/SizeLimit.pm

Criterion	Covered	Total	%
statement	32	36	88.8
branch	4	14	28.5
condition	3	8	37.5
subroutine	7	7	100.0
pod	2	2	100.0
total	48	67	71.6

package Plack::Middleware::SizeLimit;
use 5.008;
use strict;
use warnings;
use parent qw(
    Plack::Middleware
    Process::SizeLimit::Core
);
use Plack::Util::Accessor qw(
    max_unshared_size_in_kb
    min_shared_size_in_kb
    max_process_size_in_kb
    check_every_n_requests
    log_when_limits_exceeded
    callback
);

our $VERSION = '0.11';

sub prepare_app {
    my $self = shift;
    $self->set_check_interval($self->check_every_n_requests || 1);
    $self->set_max_process_size($self->max_process_size_in_kb);
    $self->set_min_shared_size($self->min_shared_size_in_kb);
    $self->set_max_unshared_size($self->max_unshared_size_in_kb);
    $self->set_callback($self->callback);
}

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

    my $res = $self->app->($env);

    return $res unless $env->{'psgix.harakiri'} or $env->{'psgix.harakiri.supported'};

    if (my $interval = $self->check_every_n_requests) {
        my $pinc = $self->get_and_pinc_request_count;
        return $res if ($pinc % $interval);
    }

    my $harakiri;
    if ($env->{'psgix.harakiri'}) {
        # Canonical implementation (Starman 0.2012+)
        $harakiri = $env->{'psgix.harakiri.commit'} = $self->_limits_are_exceeded;
    }
    elsif ($env->{'psgix.harakiri.supported'}) {
        # Legacy implementation (uWSGI)
        $harakiri = $env->{'psgix.harakiri'} = $self->_limits_are_exceeded;
    }

    if ($harakiri && $self->log_when_limits_exceeded) {
        my $message = sprintf(
            'pid %d committed harakiri (size: %d, shared: %d, unshared: %d) at %s',
            $$, $self->_check_size, $env->{REQUEST_URI},
        );
        if (my $logger = $env->{'psgix.logger'}) {
            $logger->( { message => $message, level => 'warn' } );
        }
        else {
            warn "$message\n";
        }
    }

    return $res;
}

1;
__END__