FCGI-EV-v2.0.1/0000755000175000017500000000000013260733712013166 5ustar powermanpowermanFCGI-EV-v2.0.1/Changes0000644000175000017500000000065613260733712014470 0ustar powermanpowermanRevision history for FCGI-EV v2.0.1 2018-04-03 20:20:08 EEST - Reformat doc. v2.0.0 2016-02-19 20:23:42 EET - Switch to Dist::Milla. 1.0.9 2013-10-03 16:42:55 EEST - Remove MYMETA.* 1.0.8 2012-05-13 06:01:33 EEST - Fix requirements. 1.0.7 2010-02-14 13:42:51 EET - fixed doc 1.0.6 2009-08-02 21:25:28 EEST - bugfix: perl Unicode scalars was incorrectly packed 1.0.5 2009-07-08 00:23:28 - Initial public release. FCGI-EV-v2.0.1/Build.PL0000644000175000017500000000025513260733712014464 0ustar powermanpowerman# This Build.PL for FCGI-EV was generated by Dist::Zilla::Plugin::ModuleBuildTiny 0.015. use strict; use warnings; use 5.010001; use Module::Build::Tiny 0.034; Build_PL(); FCGI-EV-v2.0.1/lib/0000755000175000017500000000000013260733712013734 5ustar powermanpowermanFCGI-EV-v2.0.1/lib/FCGI/0000755000175000017500000000000013260733712014444 5ustar powermanpowermanFCGI-EV-v2.0.1/lib/FCGI/EV.pm0000644000175000017500000003271513260733712015324 0ustar powermanpowermanpackage FCGI::EV; use 5.010001; use warnings; use strict; use utf8; use Carp; our $VERSION = 'v2.0.1'; use Scalar::Util qw( weaken ); use IO::Stream; use constant FCGI_HEADER_LEN => 8; use constant FCGI_VERSION_1 => 1; use constant FCGI_BEGIN_REQUEST => 1; use constant FCGI_END_REQUEST => 3; use constant FCGI_PARAMS => 4; use constant FCGI_STDIN => 5; use constant FCGI_STDOUT => 6; use constant FCGI_RESPONDER => 1; use constant FCGI_REQUEST_COMPLETE => 0; use constant END_REQUEST_COMPLETE => pack 'N C CCC', 0, FCGI_REQUEST_COMPLETE, 0, 0, 0; use constant MAX_CONTENT_LEN => 0xFFFF; sub new { my ($class, $sock, $handler_class) = @_; my $self = bless { io => undef, req_id => undef, params => q{}, stdin_eof => undef, handler => undef, handler_class=>$handler_class, }, $class; $self->{io} = IO::Stream->new({ fh => $sock, wait_for => IN|EOF, cb => $self, Wait_header => 1, Need_in => FCGI_HEADER_LEN, }); weaken($self->{io}); # It MAY have sense to add timeout between read() calls and timeout for # overall time until EOF on STDIN will be received. First timeout # can be about 3 minutes for slow clients, second can be about 4 hours # for uploading huge files. return; } sub DESTROY { my ($self) = @_; $self->{handler} = undef; # call handler's DESTROY while $self is alive return; } sub stdout { my ($self, $stdout, $is_eof) = @_; my $io = $self->{io}; if (length $stdout) { $io->{out_buf} .= _pack_pkt(FCGI_STDOUT, $self->{req_id}, $stdout); } if ($is_eof) { $io->{out_buf} .= _pack_pkt(FCGI_STDOUT, $self->{req_id}, q{}); $io->{out_buf} .= _pack_pkt(FCGI_END_REQUEST, $self->{req_id}, END_REQUEST_COMPLETE); $io->{wait_for} |= SENT; } $io->write(); return; } sub IO { my ($self, $io, $e, $err) = @_; if ($err) { warn "FCGI::EV: IO: $err\n"; return $io->close(); } if ($e & EOF) { return $io->close(); } if ($e & SENT) { return $io->close(); } while (length $io->{in_buf} >= $io->{Need_in}) { if ($io->{Wait_header}) { $io->{Wait_header} = 0; my ($content_len, $padding_len) = unpack 'x4 n C', $io->{in_buf}; $io->{Need_in} += $content_len + $padding_len; } else { my $pkt = substr $io->{in_buf}, 0, $io->{Need_in}, q{}; $io->{Wait_header} = 1; $io->{Need_in} = FCGI_HEADER_LEN; my $error = $self->_process($pkt); if ($error) { warn "FCGI::EV: $error\n"; return $io->close(); } } } return; } sub _process { my ($self, $pkt) = @_; my ($ver, $type, $req_id, $content_len) = unpack 'C C n n', $pkt; my $content = substr $pkt, FCGI_HEADER_LEN, $content_len; if ($ver != FCGI_VERSION_1) { return "unsupported version: $ver"; } if (defined $self->{req_id} && $self->{req_id} != $req_id) { return "unknown request id: $req_id"; } if ($type == FCGI_BEGIN_REQUEST) { my ($role) = unpack 'n', $content; if ($role != FCGI_RESPONDER) { return "role not supported: $role"; } if (defined $self->{req_id}) { return 'duplicated BEGIN_REQUEST'; } $self->{req_id} = $req_id; } elsif ($type == FCGI_PARAMS) { if ($self->{handler}) { return 'got PARAMS for existing handler'; } if (length $content) { $self->{params} .= $content; } else { my ($env, $err) = _unpack_nv($self->{params}); return $err if $err; $self->{handler} = $self->{handler_class}->new($self, $env); } } elsif ($type == FCGI_STDIN) { if (!$self->{handler}) { return 'got STDIN for non-existing handler'; } if ($self->{stdin_eof}) { return 'got STDIN after STDIN EOF'; } if (length $content) { $self->{handler}->stdin($content, 0); } else { $self->{handler}->stdin(q{}, 1); $self->{stdin_eof} = 1; } } else { return 'unknown type'; } return; } sub _unpack_nv { my ($s) = @_; my %nv; while (length $s) { my ($nlen, $vlen); for my $len ($nlen, $vlen) { ## no critic (ProhibitMagicNumbers) return (undef, 'unpack_nv: not enough data') if length $s < 1; ($len) = unpack 'C', $s; if ($len & 0x80) { return (undef, 'unpack_nv: not enough data') if length $s < 4; ($len) = unpack 'N', $s; $len &= 0x7FFFFFFF; substr $s, 0, 4, q{}; } else { substr $s, 0, 1, q{}; } ## use critic } return (undef, 'unpack_nv: not enough data') if length $s < $nlen + $vlen; my $n = substr $s, 0, $nlen, q{}; my $v = substr $s, 0, $vlen, q{}; $nv{$n} = $v; } return (\%nv, undef); } sub _pack_pkt { my ($type, $req_id, $content) = @_; $content = pack 'a*', $content; # convert from Unicode to UTF-8, if any my $pkt = q{}; while (1) { my $c = substr $content, 0, MAX_CONTENT_LEN, q{}; my $padding = q{}; $pkt .= pack 'CCnnCCa*a*', FCGI_VERSION_1, $type, $req_id, length $c, length $padding, 0, # reserved $c, $padding, ; last if !length $content; } return $pkt; } 1; # Magic true value required at end of module __END__ =encoding utf8 =head1 NAME FCGI::EV - Implement FastCGI protocol for use in EV-based applications =head1 VERSION This document describes FCGI::EV version v2.0.1 =head1 SYNOPSIS use FCGI::EV; use Some::FCGI::EV::Handler; # while in EV::loop, accept incoming connection from web server into # $sock, then start handling FastCGI protocol on that connection, # using Some::FCGI::EV::Handler for processing CGI requests: FCGI::EV->new($sock, 'Some::FCGI::EV::Handler'); # # EXAMPLE: complete FastCGI server (without error handling code) # use FCGI::EV::Std handler (download separately from CPAN) # use Socket; use Fcntl; use EV; use FCGI::EV; use FCGI::EV::Std; my $path = '/tmp/fastcgi.sock'; socket my $srvsock, AF_UNIX, SOCK_STREAM, 0; unlink $path; my $umask = umask 0; # ensure 0777 perms for unix socket bind $srvsock, sockaddr_un($path); umask $umask; listen $srvsock, SOMAXCONN; fcntl $srvsock, F_SETFL, O_NONBLOCK; my $w = EV::io $srvsock, EV::READ, sub { accept my($sock), $srvsock; fcntl $sock, F_SETFL, O_NONBLOCK; FCGI::EV->new($sock, 'FCGI::EV::Std'); }; EV::loop; =head1 DESCRIPTION This module implement FastCGI protocol for use in EV-based applications. (That mean you have to run EV::loop in your application or this module will not work.) It receive and parse data from web server, pack and send data to web server, but it doesn't process CGI requests received from web server - instead it delegate this work to another module called 'handler'. For one example of such handler, see L. FCGI::EV work using non-blocking sockets and initially was designed to use in event-based CGI applications (which able to handle multiple parallel CGI requests in single process without threads/fork). This require from CGI to avoid any operations which may block, like using SQL database - instead CGI should delegate all such tasks to remote services and talk to these services in non-blocking mode. It also possible to use it to run usual CGI.pm-based applications. If you will do this using FCGI::EV::Std handler, then only one CGI request will be executed at a time (which is probably not what you expect from FastCGI!), because FCGI::EV::Std doesn't implement any process-manager. But it's possible to develop another handlers for FCGI::EV, which will support process-management and so will handle multiple CGI request in parallel. This module doesn't require from user to use CGI.pm - any module for parsing CGI params can be used in general (details depends on used FCGI::EV handler module). =head1 INTERFACE =head2 new FCGI::EV->new( $sock, $class ); Start talking FastCGI protocol on $sock (which should be socket open to just-connected web server), and use $class to handle received CGI requests. Module $class should implement "FCGI::EV handler" interface. You can use either L from CPAN or develop your own. Return nothing. (Created FCGI::EV object will work in background and will be automatically destroyed after finishing I/O with web server.) =head1 HANDLER CLASS INTERFACE Handler class (which name provided in $class parameter to FCGI::EV->new()) must implement this interface: =over =item new( $server, \%env ) When FCGI::EV object receive initial part of CGI request (environment variables) it will call $handler_class->new() to create handler object which should process that CGI request. Parameter $server is FCGI::EV object itself. It's required to send CGI reply. WARNING! Handler may keep only weaken() reference to $server! After calling new() FCGI::EV object ($server) will continue receiving STDIN content from web server and will call $handler->stdin() each time it get next part of STDIN. =item stdin( $data, $is_eof ) The $data is next chunk of STDIN received from web server. Flag $is_eof will be true if $data was last part of STDIN. Usually handler shouldn't begin processing CGI request until all content of STDIN will be received. =item DESTROY This method is optional. It will be called when connection to web server is closed and FCGI::EV object going to die (but it's still exists when DESTROY is called - except if DESTROY was called while global destruction stage). Handler object may use DESTROY to interrupt current CGI request if web server close connection before CGI send it reply. =back =head2 SENDING CGI REPLY After handler got %env (in new()) and complete STDIN (in one or more calls of stdin()) it may start handling this CGI request and prepare reply to send to web server. To send this data it should use method $server->stdout(), where $server is object given to new() while creating handler object (it should keep weak reference to $server inside to be able to reply). =over =item stdout( $data, $is_eof ) CGI may send reply in one or more parts. Last part should have $is_eof set to true. DESTROY method of handler object will be called shortly after handler object will do $server->stdout( $data, 1 ). =back =head2 HANDLER EXAMPLE This handler will process CGI requests one-by-one (i.e. in blocking mode). On request function main::main() will be executed. That function may use standard CGI.pm module to get request parameters and send it reply using usual print to STDOUT. There no error-handling code in this example, see L for more details. package FCGI::EV::ExampleHandler; use Scalar::Util qw( weaken ); use CGI::Stateless; # needed to re-init CGI.pm state between requests sub new { my ($class, $server, $env) = @_; my $self = bless { server => $server, env => $env, stdin => q{}, }, $class; weaken($self->{server}); return $self; } sub stdin { my ($self, $stdin, $is_eof) = @_; $self->{stdin} .= $stdin; if ($is_eof) { local *STDIN; open STDIN, '<', \$self->{stdin}; local %ENV = %{ $self->{env} }; local $CGI::Q = CGI::Stateless->new(); local *STDOUT; my $reply = q{}; open STDOUT, '>', \$reply; main::main(); $self->{server}->stdout($reply, 1); } return; } =head1 DIAGNOSTICS There no errors returned in any way by this module, but there few warning messages may be printed: =over =item C<< FCGI::EV: IO: %s >> While doing I/O with web server error %s happened and connection was closed. =item C<< FCGI::EV: %s >> While parsing data from web server error %s happened and connection was closed. (That error probably mean bug either in web server or this module.) =back =head1 SUPPORT =head2 Bugs / Feature Requests Please report any bugs or feature requests through the issue tracker at L. You will be notified automatically of any progress on your issue. =head2 Source Code This is open source software. The code repository is available for public review and contribution under the terms of the license. Feel free to fork the repository and submit pull requests. L git clone https://github.com/powerman/perl-FCGI-EV.git =head2 Resources =over =item * MetaCPAN Search L =item * CPAN Ratings L =item * AnnoCPAN: Annotated CPAN documentation L =item * CPAN Testers Matrix L =item * CPANTS: A CPAN Testing Service (Kwalitee) L =back =head1 AUTHOR Alex Efros Epowerman@cpan.orgE =head1 COPYRIGHT AND LICENSE This software is Copyright (c) 2009- by Alex Efros Epowerman@cpan.orgE. This is free software, licensed under: The MIT (X11) License =cut FCGI-EV-v2.0.1/t/0000755000175000017500000000000013260733712013431 5ustar powermanpowermanFCGI-EV-v2.0.1/t/author-perlcritic.t0000644000175000017500000000063313260733712017260 0ustar powermanpowerman#!/usr/bin/perl BEGIN { unless ($ENV{AUTHOR_TESTING}) { print qq{1..0 # SKIP these tests are for testing by the author\n}; exit } } use strict; use warnings; use Test::More; eval { require Test::Perl::Critic; }; plan(skip_all=>'Test::Perl::Critic required to criticise code') if $@; Test::Perl::Critic->import( -verbose => 9, # verbose 6 will hide rule name ); all_critic_ok(); FCGI-EV-v2.0.1/t/00.load.t0000644000175000017500000000015413260733712014753 0ustar powermanpowermanuse Test::More tests => 1; BEGIN { use_ok( 'FCGI::EV' ); } diag( "Testing FCGI::EV $FCGI::EV::VERSION" ); FCGI-EV-v2.0.1/t/01.export.t0000644000175000017500000000073113260733712015357 0ustar powermanpowermanuse warnings; use strict; use Test::More; #use Your::Module; my @exports # = qw( func1 func2 ) ; my @not_exports # = qw( func3 func4 ) ; plan +(@exports + @not_exports) ? ( tests => @exports + @not_exports ) : ( skip_all => q{This module doesn't export anything} ) ; for my $export (@exports) { can_ok( __PACKAGE__, $export ); } for my $not_export (@not_exports) { ok( ! __PACKAGE__->can($not_export) ); } FCGI-EV-v2.0.1/t/release-distribution.t0000644000175000017500000000064413260733712017757 0ustar powermanpowerman BEGIN { unless ($ENV{RELEASE_TESTING}) { print qq{1..0 # SKIP these tests are for release candidate testing\n}; exit } } use Test::More; eval { require Test::Distribution }; plan( skip_all => 'Test::Distribution not installed' ) if $@; Test::Distribution->import( podcoveropts => { also_private => [ qr/^(?:IO)$/, ], # pod_from => 'MAIN PM FILE HERE', } ); FCGI-EV-v2.0.1/t/author-pod-syntax.t0000644000175000017500000000045413260733712017227 0ustar powermanpowerman#!perl BEGIN { unless ($ENV{AUTHOR_TESTING}) { print qq{1..0 # SKIP these tests are for testing by the author\n}; exit } } # This file was automatically generated by Dist::Zilla::Plugin::PodSyntaxTests. use strict; use warnings; use Test::More; use Test::Pod 1.41; all_pod_files_ok(); FCGI-EV-v2.0.1/README0000644000175000017500000002003213260733712014043 0ustar powermanpowermanNAME FCGI::EV - Implement FastCGI protocol for use in EV-based applications VERSION This document describes FCGI::EV version v2.0.1 SYNOPSIS use FCGI::EV; use Some::FCGI::EV::Handler; # while in EV::loop, accept incoming connection from web server into # $sock, then start handling FastCGI protocol on that connection, # using Some::FCGI::EV::Handler for processing CGI requests: FCGI::EV->new($sock, 'Some::FCGI::EV::Handler'); # # EXAMPLE: complete FastCGI server (without error handling code) # use FCGI::EV::Std handler (download separately from CPAN) # use Socket; use Fcntl; use EV; use FCGI::EV; use FCGI::EV::Std; my $path = '/tmp/fastcgi.sock'; socket my $srvsock, AF_UNIX, SOCK_STREAM, 0; unlink $path; my $umask = umask 0; # ensure 0777 perms for unix socket bind $srvsock, sockaddr_un($path); umask $umask; listen $srvsock, SOMAXCONN; fcntl $srvsock, F_SETFL, O_NONBLOCK; my $w = EV::io $srvsock, EV::READ, sub { accept my($sock), $srvsock; fcntl $sock, F_SETFL, O_NONBLOCK; FCGI::EV->new($sock, 'FCGI::EV::Std'); }; EV::loop; DESCRIPTION This module implement FastCGI protocol for use in EV-based applications. (That mean you have to run EV::loop in your application or this module will not work.) It receive and parse data from web server, pack and send data to web server, but it doesn't process CGI requests received from web server - instead it delegate this work to another module called 'handler'. For one example of such handler, see FCGI::EV::Std. FCGI::EV work using non-blocking sockets and initially was designed to use in event-based CGI applications (which able to handle multiple parallel CGI requests in single process without threads/fork). This require from CGI to avoid any operations which may block, like using SQL database - instead CGI should delegate all such tasks to remote services and talk to these services in non-blocking mode. It also possible to use it to run usual CGI.pm-based applications. If you will do this using FCGI::EV::Std handler, then only one CGI request will be executed at a time (which is probably not what you expect from FastCGI!), because FCGI::EV::Std doesn't implement any process-manager. But it's possible to develop another handlers for FCGI::EV, which will support process-management and so will handle multiple CGI request in parallel. This module doesn't require from user to use CGI.pm - any module for parsing CGI params can be used in general (details depends on used FCGI::EV handler module). INTERFACE new FCGI::EV->new( $sock, $class ); Start talking FastCGI protocol on $sock (which should be socket open to just-connected web server), and use $class to handle received CGI requests. Module $class should implement "FCGI::EV handler" interface. You can use either FCGI::EV::Std from CPAN or develop your own. Return nothing. (Created FCGI::EV object will work in background and will be automatically destroyed after finishing I/O with web server.) HANDLER CLASS INTERFACE Handler class (which name provided in $class parameter to FCGI::EV->new()) must implement this interface: new( $server, \%env ) When FCGI::EV object receive initial part of CGI request (environment variables) it will call $handler_class->new() to create handler object which should process that CGI request. Parameter $server is FCGI::EV object itself. It's required to send CGI reply. WARNING! Handler may keep only weaken() reference to $server! After calling new() FCGI::EV object ($server) will continue receiving STDIN content from web server and will call $handler->stdin() each time it get next part of STDIN. stdin( $data, $is_eof ) The $data is next chunk of STDIN received from web server. Flag $is_eof will be true if $data was last part of STDIN. Usually handler shouldn't begin processing CGI request until all content of STDIN will be received. DESTROY This method is optional. It will be called when connection to web server is closed and FCGI::EV object going to die (but it's still exists when DESTROY is called - except if DESTROY was called while global destruction stage). Handler object may use DESTROY to interrupt current CGI request if web server close connection before CGI send it reply. SENDING CGI REPLY After handler got %env (in new()) and complete STDIN (in one or more calls of stdin()) it may start handling this CGI request and prepare reply to send to web server. To send this data it should use method $server->stdout(), where $server is object given to new() while creating handler object (it should keep weak reference to $server inside to be able to reply). stdout( $data, $is_eof ) CGI may send reply in one or more parts. Last part should have $is_eof set to true. DESTROY method of handler object will be called shortly after handler object will do $server->stdout( $data, 1 ). HANDLER EXAMPLE This handler will process CGI requests one-by-one (i.e. in blocking mode). On request function main::main() will be executed. That function may use standard CGI.pm module to get request parameters and send it reply using usual print to STDOUT. There no error-handling code in this example, see FCGI::EV::Std for more details. package FCGI::EV::ExampleHandler; use Scalar::Util qw( weaken ); use CGI::Stateless; # needed to re-init CGI.pm state between requests sub new { my ($class, $server, $env) = @_; my $self = bless { server => $server, env => $env, stdin => q{}, }, $class; weaken($self->{server}); return $self; } sub stdin { my ($self, $stdin, $is_eof) = @_; $self->{stdin} .= $stdin; if ($is_eof) { local *STDIN; open STDIN, '<', \$self->{stdin}; local %ENV = %{ $self->{env} }; local $CGI::Q = CGI::Stateless->new(); local *STDOUT; my $reply = q{}; open STDOUT, '>', \$reply; main::main(); $self->{server}->stdout($reply, 1); } return; } DIAGNOSTICS There no errors returned in any way by this module, but there few warning messages may be printed: FCGI::EV: IO: %s While doing I/O with web server error %s happened and connection was closed. FCGI::EV: %s While parsing data from web server error %s happened and connection was closed. (That error probably mean bug either in web server or this module.) SUPPORT Bugs / Feature Requests Please report any bugs or feature requests through the issue tracker at https://github.com/powerman/perl-FCGI-EV/issues. You will be notified automatically of any progress on your issue. Source Code This is open source software. The code repository is available for public review and contribution under the terms of the license. Feel free to fork the repository and submit pull requests. https://github.com/powerman/perl-FCGI-EV git clone https://github.com/powerman/perl-FCGI-EV.git Resources * MetaCPAN Search https://metacpan.org/search?q=FCGI-EV * CPAN Ratings http://cpanratings.perl.org/dist/FCGI-EV * AnnoCPAN: Annotated CPAN documentation http://annocpan.org/dist/FCGI-EV * CPAN Testers Matrix http://matrix.cpantesters.org/?dist=FCGI-EV * CPANTS: A CPAN Testing Service (Kwalitee) http://cpants.cpanauthors.org/dist/FCGI-EV AUTHOR Alex Efros COPYRIGHT AND LICENSE This software is Copyright (c) 2009- by Alex Efros . This is free software, licensed under: The MIT (X11) License FCGI-EV-v2.0.1/cpanfile0000644000175000017500000000046213260733712014674 0ustar powermanpowermanrequires 'perl', '5.010001'; requires 'EV'; requires 'IO::Stream'; requires 'Scalar::Util'; on configure => sub { requires 'Module::Build::Tiny', '0.034'; }; on test => sub { requires 'Test::More'; }; on develop => sub { requires 'Test::Distribution'; requires 'Test::Perl::Critic'; }; FCGI-EV-v2.0.1/LICENSE0000644000175000017500000000223213260733712014172 0ustar powermanpowermanThis software is Copyright (c) 2009- by Alex Efros . This is free software, licensed under: The MIT (X11) License The MIT License Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. FCGI-EV-v2.0.1/dist.ini0000644000175000017500000000045513260733712014636 0ustar powermanpowerman[@Milla] [MetaProvides::Package] [Substitute] code = s/^(This document describes \S+ version |VERSION=['"])([^'"\r\n]*)/my($s,$v)=($1,$2);my%h=%Term::ReadLine::Gnu::Attribs;$s.($h{prompt}?($h{line_buffer}||$h{prompt}=~m{ \[(.*)\]})[0]:$v)/e [GitHubREADME::Badge] badges = travis badges = coveralls FCGI-EV-v2.0.1/META.json0000644000175000017500000000345313260733712014614 0ustar powermanpowerman{ "abstract" : "Implement FastCGI protocol for use in EV-based applications", "author" : [ "Alex Efros " ], "dynamic_config" : 0, "generated_by" : "Dist::Milla version v1.0.18, Dist::Zilla version 6.011, CPAN::Meta::Converter version 2.150010", "license" : [ "mit" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "FCGI-EV", "no_index" : { "directory" : [ "eg", "examples", "inc", "share", "t", "xt" ] }, "prereqs" : { "configure" : { "requires" : { "Module::Build::Tiny" : "0.034" } }, "develop" : { "requires" : { "Dist::Milla" : "v1.0.18", "Test::Distribution" : "0", "Test::Perl::Critic" : "0", "Test::Pod" : "1.41" } }, "runtime" : { "requires" : { "EV" : "0", "IO::Stream" : "0", "Scalar::Util" : "0", "perl" : "5.010001" } }, "test" : { "requires" : { "Test::More" : "0" } } }, "provides" : { "FCGI::EV" : { "file" : "lib/FCGI/EV.pm", "version" : "v2.0.1" } }, "release_status" : "stable", "resources" : { "bugtracker" : { "web" : "https://github.com/powerman/perl-FCGI-EV/issues" }, "homepage" : "https://github.com/powerman/perl-FCGI-EV", "repository" : { "type" : "git", "url" : "https://github.com/powerman/perl-FCGI-EV.git", "web" : "https://github.com/powerman/perl-FCGI-EV" } }, "version" : "v2.0.1", "x_serialization_backend" : "JSON::XS version 3.04" } FCGI-EV-v2.0.1/MANIFEST0000644000175000017500000000041513260733712014317 0ustar powermanpowerman# This file was automatically generated by Dist::Zilla::Plugin::Manifest v6.011. Build.PL Changes LICENSE MANIFEST META.json META.yml README cpanfile dist.ini lib/FCGI/EV.pm t/00.load.t t/01.export.t t/author-perlcritic.t t/author-pod-syntax.t t/release-distribution.t FCGI-EV-v2.0.1/META.yml0000644000175000017500000000164713260733712014447 0ustar powermanpowerman--- abstract: 'Implement FastCGI protocol for use in EV-based applications' author: - 'Alex Efros ' build_requires: Test::More: '0' configure_requires: Module::Build::Tiny: '0.034' dynamic_config: 0 generated_by: 'Dist::Milla version v1.0.18, Dist::Zilla version 6.011, CPAN::Meta::Converter version 2.150010' license: mit meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: FCGI-EV no_index: directory: - eg - examples - inc - share - t - xt provides: FCGI::EV: file: lib/FCGI/EV.pm version: v2.0.1 requires: EV: '0' IO::Stream: '0' Scalar::Util: '0' perl: '5.010001' resources: bugtracker: https://github.com/powerman/perl-FCGI-EV/issues homepage: https://github.com/powerman/perl-FCGI-EV repository: https://github.com/powerman/perl-FCGI-EV.git version: v2.0.1 x_serialization_backend: 'YAML::Tiny version 1.73'