HTTP-Engine-Middleware

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

t/200_middlewares/profile.t
t/200_middlewares/reverseproxy.t
t/200_middlewares/static.t
t/200_middlewares/static_404handler.t
t/200_middlewares/status-memory.t
t/200_middlewares/status.t
t/200_middlewares/uploadtemp/base.pm
t/200_middlewares/uploadtemp/base_dir.t
t/200_middlewares/uploadtemp/cleanup.t
t/200_middlewares/uploadtemp/default.t
t/200_middlewares/uploadtemp/keepalive.t
t/200_middlewares/uploadtemp/keepalive_off.t
t/200_middlewares/uploadtemp/lazy.t
t/200_middlewares/uploadtemp/template.t
t/200_middlewares/uploadtemp/tmpdir.t
t/200_middlewares/uploadtemp/tmpdir_template.t
t/htdocs/css/mobile.css
t/htdocs/file.unknown_ext
t/htdocs/index.html
t/htdocs/manual/index.html
t/htdocs/null.html
t/htdocs/robots.txt

lib/HTTP/Engine/Middleware.pm  view on Meta::CPAN

                $req = $ret;
            }
            push @run_middlewares, $instance;
        }
        my $msg;
        unless ($res) {
            $self->diecatch(0);
            local $@;
            eval {
                $res = $handle->($req);
                $self->diecatch(0); # yes! i'm still alive!
            };
            $msg = $@ if !$self->diecatch && $@;
        }
        die $msg if $msg;
        for my $instance (reverse @run_middlewares) {
            for my $code (reverse @{ $instance->after_handles }) {
                $res = $code->($self, $instance, $req, $res);
            }
        }

lib/HTTP/Engine/Middleware/UploadTemp.pm  view on Meta::CPAN

package HTTP::Engine::Middleware::UploadTemp;
use HTTP::Engine::Middleware;

use File::Temp 'tempdir';
use File::Path 'rmtree';

has 'keepalive' => (
    is      => 'ro',
    isa     => 'Bool',
    default => 1,
);

has 'lazy' => (
    is      => 'ro',
    isa     => 'Bool',
    default => 0,
);

lib/HTTP/Engine/Middleware/UploadTemp.pm  view on Meta::CPAN

    isa => 'Str',
);

{
    my $TMPDIR;
    sub _make_tempdir {
        return $TMPDIR if $TMPDIR;
        my $self = shift;

        my %option = (
            CLEANUP => ($self->cleanup && $self->keepalive),
            TMPDIR  => $self->tmpdir,
        );
        $option{DIR} = $self->base_dir if $self->base_dir;

        if ($self->template) {
            $TMPDIR = tempdir($self->template, %option);
        } else {
            $TMPDIR = tempdir(%option);
        }

lib/HTTP/Engine/Middleware/UploadTemp.pm  view on Meta::CPAN

        );
        } else {
            $req->request_builder->upload_tmp( $self->_make_tempdir );
        }

        $HAS_UPLOAD_TMP = 1;
        return $req;
    };

    after_handle {
        return $_[3] if $_[1]->keepalive;
        my(undef, $self, $req, $res) = @_;
    
        $req->request_builder->upload_tmp(undef);
        $HAS_UPLOAD_TMP = 0;

        return $res unless $TMPDIR;

        delete $req->{http_body} if exists $req->{http_body}; # HTTP::Body object is delete first                                                                
        rmtree $TMPDIR;
        undef $TMPDIR;

lib/HTTP/Engine/Middleware/UploadTemp.pm  view on Meta::CPAN

=head2 like lazy option

  sub your_handler {
      my $req = shift;
      $req->builder_options->{upload_tmp} = sub { File::Temp->newdir };
      my $file = $req->upload('file');
      ...
  }

=head2 like keepalive option

  my $cache;
  sub your_handler {
      my $req = shift;
      $cache ||= File::Temp->newdir;
      $req->builder_options->{upload_tmp} = $cache;
      my $file = $req->upload('file');
      ...
  }


=head2 OLD SYNOPSIS

    my $mw = HTTP::Engine::Middleware->new;
    $mw->install( 'HTTP::Engine::Middleware::UploadTemp' => {
        keepalive => 0,          # generate temporary directory to 1 request only
        cleanup   => 1,          # CLEANUP option for File::Temp::tempdir
        tmpdir    => 1,          # TMPDIR option for File::Temp::tempdir
        base_dir  => '/tmp',     # DIR option for File::Temp::tempdir
        template  => 'FOO_XXXX', # template option for File::Temp::tempdir
        lazy      => 1,          # lazy generate for temporary directory
    });
    HTTP::Engine->new(
        interface => {
            module => 'YourFavoriteInterfaceHere',
            request_handler => $mw->handler( \&handler ),

t/200_middlewares/uploadtemp/base_dir.t  view on Meta::CPAN

    };
    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['README'],
        ],
    );
    like($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
    like($upload_tmpdir, qr{BASE_TMP_}, 'use template');
    ok(-d $upload_tmpdir, 'alive tmpdir');
};
ok(rmtree($upload_tmpdir, 0), 'rmtree');

t/200_middlewares/uploadtemp/cleanup.t  view on Meta::CPAN

};

$he->run(
    POST 'http://example.com/',
    Content_Type => 'form-data',
    Content      => [
        upfile => ['README'],
    ],
);
like($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
ok(-d $upload_tmpdir, 'alive tmpdir');


END {
    # cleanup by File::Temp's END block
    ok(!-d $upload_tmpdir, 'not alive tmpdir');
    ok(!rmtree($upload_tmpdir, 0), 'rmtree');
}

t/200_middlewares/uploadtemp/default.t  view on Meta::CPAN

        my $req = shift;
        $upload_tmpdir = $req->request_builder->upload_tmp;
        if ($req->method eq 'POST') {
            ok(-f $req->upload('upfile')->tempname, 'upload file');
        }
    };

    $he->run(
        GET 'http://example.com/',
    );
    ok(-d $upload_tmpdir, 'alive tmpdir');

    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['README'],
        ],
    );
    like($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
    ok(-d $upload_tmpdir, 'alive tmpdir');
    my $first_tmpdir = $upload_tmpdir;

    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['Makefile.PL'],
        ],
    );
    is($upload_tmpdir, $first_tmpdir, 'recycle tmpdir');

t/200_middlewares/uploadtemp/keepalive.t  view on Meta::CPAN

my $base_tmp   = quotemeta(File::Spec->tmpdir);
my $upload_tmpdir;
do {
    my $he = new_engine {
        my $req = shift;
        $upload_tmpdir = $req->request_builder->upload_tmp;
        if ($req->method eq 'post') {
            ok(-f $req->upload('upfile')->tempname, 'upload file');
        }
    } {
        keepalive => 1
    };

    $he->run(
        GET 'http://example.com/',
    );
    ok(-d $upload_tmpdir, 'alive tmpdir');

    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['README'],
        ],
    );
    like($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
    ok(-d $upload_tmpdir, 'alive tmpdir');
    my $first_tmpdir = $upload_tmpdir;

    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['Makefile.PL'],
        ],
    );
    is($upload_tmpdir, $first_tmpdir, 'recycle tmpdir');
};
ok(-d $upload_tmpdir, 'alive tmpdir out of scop');
ok(rmtree($upload_tmpdir, 0), 'rmtree');

t/200_middlewares/uploadtemp/keepalive_off.t  view on Meta::CPAN

my $base_tmp   = quotemeta(File::Spec->tmpdir);
my $upload_tmpdir;
do {
    my $he = new_engine {
        my $req = shift;
        $upload_tmpdir = $req->request_builder->upload_tmp;
        if ($req->method eq 'POST') {
            ok(-f $req->upload('upfile')->tempname, 'upload file');
        }
    } {
        keepalive => 0,
    };

    $he->run(
        GET 'http://example.com/',
    );
    ok(!-d $upload_tmpdir, 'not alive tmpdir');

    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['README'],
        ],
    );
    like($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
    ok(!-d $upload_tmpdir, 'not alive tmpdir');
    my $first_tmpdir = $upload_tmpdir;

    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['Makefile.PL'],
        ],
    );
    isnt($upload_tmpdir, $first_tmpdir, 'not recycle tmpdir');

t/200_middlewares/uploadtemp/lazy.t  view on Meta::CPAN

            ok(-f $req->upload('upfile')->tempname, 'upload file');
        }
    } {
        lazy => 1,
        cleanup => 1,
    };

    $he->run(
        GET 'http://example.com/',
    );
    ok(!$upload_tmpdir->tempdir, 'not alive tmpdir');

    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['README'],
        ],
    );
    ok($upload_tmpdir->tempdir, 'alive tmpdir');
    like($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
    ok(-d $upload_tmpdir, 'alive tmpdir created');
    my $first_tmpdir = $upload_tmpdir;

    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['Makefile.PL'],
        ],
    );
    is($upload_tmpdir, $first_tmpdir, 'recycle tmpdir');
};

END {
    # cleanup by File::Temp's END block
    ok(!-d $upload_tmpdir, 'not alive tmpdir');
    ok(!rmtree("$upload_tmpdir", 0), 'rmtree'); # $upload_tmpdir is HTTP::Engine::Middleware::UploadTemp::LazyObject object
}

t/200_middlewares/uploadtemp/template.t  view on Meta::CPAN

$he->run(
    POST 'http://example.com/',
    Content_Type => 'form-data',
    Content      => [
        upfile => ['README'],
    ],
);
unlike($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
like($upload_tmpdir, qr{TESTTMPDIR_}, 'use template');
ok(-d $upload_tmpdir, 'alive tmpdir');

ok(rmtree($upload_tmpdir, 0), 'rmtree');

t/200_middlewares/uploadtemp/tmpdir.t  view on Meta::CPAN

        tmpdir => 1,
    };
    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['README'],
        ],
    );
    like($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
    ok(-d $upload_tmpdir, 'alive tmpdir');
};
ok(rmtree($upload_tmpdir, 0), 'rmtree');

t/200_middlewares/uploadtemp/tmpdir_template.t  view on Meta::CPAN

    };
    $he->run(
        POST 'http://example.com/',
        Content_Type => 'form-data',
        Content      => [
            upfile => ['README'],
        ],
    );
    like($upload_tmpdir, qr{\A$base_tmp}, 'base tmpdir');
    like($upload_tmpdir, qr{TESTTMPDIR_}, 'use template');
    ok(-d $upload_tmpdir, 'alive tmpdir');
};
ok(rmtree($upload_tmpdir, 0), 'rmtree');