CGI-Fast-2.13/ 000755 000765 000120 00000000000 13203506566 014233 5 ustar 00leejohnson admin 000000 000000 CGI-Fast-2.13/Changes 000644 000765 000120 00000006033 13203506344 015522 0 ustar 00leejohnson admin 000000 000000 Revision history for CGI::Fast
2.13 2017-11-17
[TESTING]
remove use of Test::Deep completely (GH #17)
2.12 2016-11-22
[DOCUMENTATION]
- tweak docs about overriding STDIN due to interference with POST
requests (GH #16, thanks to melak)
2.11 2016-11-17
[FIX]
- make sure we use CGI::Carp as we depend on it (GH #15, thanks to melak)
2.10 2015-06-22
[DOCUMENTATION]
- Kwalitee improvements in distribution
2.09 2015-03-08
[DOCUMENTATION]
- Clarify order of use statements when using both CGI and CGI::Fast
- Replace indirect object notation with ->new
[TESTING]
- Tests for CGI imports and load order
2.07 2015-02-23
[FIX]
- test added in 2.06 should use File::Temp
2.06 2015-02-23
[FEATURE]
- Add support for changing socket permissions. Thanks to powerman
for the patch and tests
2.05 2014-12-11
[TESTING]
remove useless use of Test::Deep in tests
this patch was sourced from the fedora perl-devel mailing list[1],
in which i see more patches for CGI - fedora perl-devel people: if
you're going to patch modules then please send those patches upstream
where relevant. many perl modules are now on github (including this
one) so it's easy, and it prevents alternate versions of modules
that could lead to frustrating debugging sessions because *your*
version of FCGI (2.04) is different to what the *real* version of
FCGI (2.04) is[2].
* [1] https://lists.fedoraproject.org/pipermail/perl-devel
* [2] the "real" version of FCGI being that available on CPAN
2.04 2014-10-12
[TESTING]
- Fix tests for recent version of CGI (v4.05+), which removed the
-private_tempfiles pragma and PRIVATE_TEMPFILES variable, so use
on that is still available for testing
2.03 2014-09-06
[DOCUMENTATION]
- Kwalitee improvements in distribution (LICENSE)
[TESTING]
- Add t/006_changes.t to check Changes file
2.02 2014-06-05
[INTERNALS]
- allow FCGI_SOCKET_PATH and FCGI_LISTEN_QUEUE ENV variables to be
passed in as import settings, although favour ENV variables if set
- delay creation of FCGI::Request until the first call to CGI::Fast->new
(RT #70609), removing the need to defined these in a BEGIN block
- add test to check ENV values are not recycled from old requests and not
set as defaults when the FCGI_SOCKET_PATH is used (RT #65492)
- add file_handles method to allow setting of file handles to be passed
to FCGI (RT #94423)
[DOCUMENTATION]
- document above changes
- general tidy up
2.01 2014-05-27
[DOCUMENTATION]
- update perldoc to list current bugtracker and maintainer
- pod2readme the perldoc to replace content of README with something sane
2.00 2014-05-22
[DOCUMENTATION]
- Repointing bugtracker at newly forked github repo
- Tickets migrated from RT to github issues (both CGI and CGI.pm distributions)
- Bump version to 2.00 for clear boundary of above changes
- For previous Changes please see CGI.pm prior to 3.65_01
CGI-Fast-2.13/MANIFEST 000644 000765 000120 00000000557 13203506566 015373 0 ustar 00leejohnson admin 000000 000000 Changes
lib/CGI/Fast.pm
Makefile.PL
MANIFEST
README
README.md
t/001_basic.t
t/002_import.t
t/003_env_pollution.t
t/004_fcgi_file_handles.t
t/005_no_file_handles.t
t/006_changes.t
t/007_socket_perm.t
META.yml Module YAML meta-data (added by MakeMaker)
META.json Module JSON meta-data (added by MakeMaker)
CGI-Fast-2.13/META.json 000644 000765 000120 00000002522 13203506566 015655 0 ustar 00leejohnson admin 000000 000000 {
"abstract" : "unknown",
"author" : [
"unknown"
],
"dynamic_config" : 1,
"generated_by" : "ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version 2.150010",
"license" : [
"perl_5"
],
"meta-spec" : {
"url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
"version" : "2"
},
"name" : "CGI-Fast",
"no_index" : {
"directory" : [
"t",
"inc",
"t"
]
},
"prereqs" : {
"build" : {
"requires" : {}
},
"configure" : {
"requires" : {}
},
"runtime" : {
"requires" : {
"CGI" : "4",
"Carp" : "0",
"FCGI" : "0.67",
"if" : "0",
"perl" : "5.008001"
}
},
"test" : {
"requires" : {
"File::Temp" : "0",
"Test::More" : "0"
}
}
},
"release_status" : "stable",
"resources" : {
"bugtracker" : {
"web" : "https://github.com/leejo/cgi-fast/issues"
},
"homepage" : "https://metacpan.org/module/CGI::Fast",
"license" : [
"http://dev.perl.org/licenses/"
],
"repository" : {
"url" : "https://github.com/leejo/cgi-fast"
}
},
"version" : "2.13",
"x_serialization_backend" : "JSON::PP version 2.27400_02"
}
CGI-Fast-2.13/META.yml 000644 000765 000120 00000001355 13203506566 015510 0 ustar 00leejohnson admin 000000 000000 ---
abstract: unknown
author:
- unknown
build_requires:
File::Temp: '0'
Test::More: '0'
configure_requires: {}
dynamic_config: 1
generated_by: 'ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version 2.150010'
license: perl
meta-spec:
url: http://module-build.sourceforge.net/META-spec-v1.4.html
version: '1.4'
name: CGI-Fast
no_index:
directory:
- t
- inc
- t
requires:
CGI: '4'
Carp: '0'
FCGI: '0.67'
if: '0'
perl: '5.008001'
resources:
bugtracker: https://github.com/leejo/cgi-fast/issues
homepage: https://metacpan.org/module/CGI::Fast
license: http://dev.perl.org/licenses/
repository: https://github.com/leejo/cgi-fast
version: '2.13'
x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
CGI-Fast-2.13/Makefile.PL 000644 000765 000120 00000003216 13203506205 016175 0 ustar 00leejohnson admin 000000 000000 use ExtUtils::MakeMaker;
my $mm = $ExtUtils::MakeMaker::VERSION;
# See lib/ExtUtils/MakeMaker.pm for details of how to influence
# the contents of the Makefile that is written.
WriteMakefile(
INSTALLDIRS => ( $] >= 5.012 ? 'site' : 'perl' ),
NAME => 'CGI::Fast',
DISTNAME => 'CGI-Fast',
VERSION_FROM => 'lib/CGI/Fast.pm',
LICENSE => 'perl',
MIN_PERL_VERSION => '5.8.1',
PREREQ_PM => {
'if' => 0, # core in 5.6.2 and later, for deprecate.pm
'CGI' => 4.00,
'FCGI' => 0.67,
'Carp' => 0, # Carp was first released with perl 6
},
TEST_REQUIRES => {
'Test::More' => 0,
'File::Temp' => 0,
},
test => { TESTS => 't/*.t' },
linkext => { LINKTYPE => '' }, # no link needed
dist => {
COMPRESS => 'gzip -9f',
SUFFIX => 'gz',
ZIP => '/usr/bin/zip',
ZIPFLAGS => '-rl'
},
(
$mm < 6.46
? ()
: ( META_MERGE => {
requires => { perl => '5.008001' },
resources => {
license => 'http://dev.perl.org/licenses/',
homepage => 'https://metacpan.org/module/CGI::Fast',
repository => 'https://github.com/leejo/cgi-fast',
bugtracker => 'https://github.com/leejo/cgi-fast/issues',
},
no_index => { directory => [qw/t/] },
},
META_ADD => {
build_requires => {},
configure_requires => {}
},
)
),
);
CGI-Fast-2.13/README 000644 000765 000120 00000014204 13015042445 015104 0 ustar 00leejohnson admin 000000 000000 # NAME
CGI::Fast - CGI Interface for Fast CGI
# SYNOPSIS
use CGI::Fast
socket_path => '9000',
socket_perm => 0777,
listen_queue => 50;
use CGI qw/ :standard /;
$COUNTER = 0;
# optional, will default to STDOUT, STDERR
CGI::Fast->file_handles({
fcgi_output_file_handle => IO::Handle->new,
fcgi_error_file_handle => IO::Handle->new,
});
while ($q = CGI::Fast->new) {
process_request($q);
}
# DESCRIPTION
CGI::Fast is a subclass of the CGI object created by CGI.pm. It is
specialized to work with the FCGI module, which greatly speeds up CGI
scripts by turning them into persistently running server processes.
Scripts that perform time-consuming initialization processes, such as
loading large modules or opening persistent database connections, will
see large performance improvements.
# OTHER PIECES OF THE PUZZLE
In order to use CGI::Fast you'll need the FCGI module. See
http://www.cpan.org/ for details.
# WRITING FASTCGI PERL SCRIPTS
FastCGI scripts are persistent: one or more copies of the script
are started up when the server initializes, and stay around until
the server exits or they die a natural death. After performing
whatever one-time initialization it needs, the script enters a
loop waiting for incoming connections, processing the request, and
waiting some more.
A typical FastCGI script will look like this:
#!perl
use CGI::Fast;
do_some_initialization();
while ($q = CGI::Fast->new) {
process_request($q);
}
Each time there's a new request, CGI::Fast returns a
CGI object to your loop. The rest of the time your script
waits in the call to new(). When the server requests that
your script be terminated, new() will return undef. You can
of course exit earlier if you choose. A new version of the
script will be respawned to take its place (this may be
necessary in order to avoid Perl memory leaks in long-running
scripts).
CGI.pm's default CGI object mode also works. Just modify the loop
this way:
while (CGI::Fast->new) {
process_request();
}
Calls to header(), start\_form(), etc. will all operate on the
current request.
# INSTALLING FASTCGI SCRIPTS
See the FastCGI developer's kit documentation for full details. On
the Apache server, the following line must be added to srm.conf:
AddType application/x-httpd-fcgi .fcgi
FastCGI scripts must end in the extension .fcgi. For each script you
install, you must add something like the following to srm.conf:
FastCgiServer /usr/etc/httpd/fcgi-bin/file_upload.fcgi -processes 2
This instructs Apache to launch two copies of file\_upload.fcgi at
startup time.
# USING FASTCGI SCRIPTS AS CGI SCRIPTS
Any script that works correctly as a FastCGI script will also work
correctly when installed as a vanilla CGI script. However it will
not see any performance benefit.
# EXTERNAL FASTCGI SERVER INVOCATION
FastCGI supports a TCP/IP transport mechanism which allows FastCGI scripts to run
external to the webserver, perhaps on a remote machine. To configure the
webserver to connect to an external FastCGI server, you would add the following
to your srm.conf:
FastCgiExternalServer /usr/etc/httpd/fcgi-bin/file_upload.fcgi -host sputnik:8888
Two environment variables affect how the `CGI::Fast` object is created,
allowing `CGI::Fast` to be used as an external FastCGI server. (See `FCGI`
documentation for `FCGI::OpenSocket` for more information.)
You can set these as ENV variables or imports in the use CGI::Fast statement.
If the ENV variables are set then these will be favoured so you can override
the import statements on the command line, etc.
- FCGI\_SOCKET\_PATH / socket\_path
The address (TCP/IP) or path (UNIX Domain) of the socket the external FastCGI
script to which bind an listen for incoming connections from the web server.
- FCGI\_SOCKET\_PERM / socket\_perm
Permissions for UNIX Domain socket.
- FCGI\_LISTEN\_QUEUE / listen\_queue
Maximum length of the queue of pending connections, defaults to 100.
For example:
use CGI::Fast
socket_path => "sputnik:8888",
listen_queue => "50"
;
use CGI qw/ :standard /;
do_some_initialization();
while ($q = CGI::Fast->new) {
process_request($q);
}
Or:
use CGI::Fast;
use CGI qw/ :standard /;
do_some_initialization();
$ENV{FCGI_SOCKET_PATH} = "sputnik:8888";
$ENV{FCGI_LISTEN_QUEUE} = 50;
while ($q = CGI::Fast->new) {
process_request($q);
}
Note the importance of having use CGI after use CGI::Fast as this will
prevent any CGI import pragmas being overwritten by CGI::Fast. You can
use CGI::Fast as a drop in replacement like so:
use CGI::Fast qw/ :standard /
# FILE HANDLES
FCGI defaults to using STDOUT and STDERR as its output filehandles - this
may lead to unexpected redirect of output if you migrate scripts from CGI.pm
to CGI::Fast. To get around this you can use the file\_handles method, which
you must do **before** the first call to CGI::Fast->new. For example using
IO::Handle:
CGI::Fast->file_handles({
fcgi_output_file_handle => IO::Handle->new,
fcgi_error_file_handle => IO::Handle->new,
});
while (CGI::Fast->new) {
..
}
Overriding STDIN using the `fcgi_input_file_handle` key is also possible,
however doing so is likely to break at least POST requests.
# CAVEATS
I haven't tested this very much.
# LICENSE
Copyright 1996-1998, Lincoln D. Stein. All rights reserved. Currently
maintained by Lee Johnson
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
Address bug reports and comments to:
https://github.com/leejo/cgi-fast
# BUGS
This section intentionally left blank.
# SEE ALSO
[CGI::Carp](https://metacpan.org/pod/CGI::Carp), [CGI](https://metacpan.org/pod/CGI)
CGI-Fast-2.13/README.md 000644 000765 000120 00000014204 13015042445 015503 0 ustar 00leejohnson admin 000000 000000 # NAME
CGI::Fast - CGI Interface for Fast CGI
# SYNOPSIS
use CGI::Fast
socket_path => '9000',
socket_perm => 0777,
listen_queue => 50;
use CGI qw/ :standard /;
$COUNTER = 0;
# optional, will default to STDOUT, STDERR
CGI::Fast->file_handles({
fcgi_output_file_handle => IO::Handle->new,
fcgi_error_file_handle => IO::Handle->new,
});
while ($q = CGI::Fast->new) {
process_request($q);
}
# DESCRIPTION
CGI::Fast is a subclass of the CGI object created by CGI.pm. It is
specialized to work with the FCGI module, which greatly speeds up CGI
scripts by turning them into persistently running server processes.
Scripts that perform time-consuming initialization processes, such as
loading large modules or opening persistent database connections, will
see large performance improvements.
# OTHER PIECES OF THE PUZZLE
In order to use CGI::Fast you'll need the FCGI module. See
http://www.cpan.org/ for details.
# WRITING FASTCGI PERL SCRIPTS
FastCGI scripts are persistent: one or more copies of the script
are started up when the server initializes, and stay around until
the server exits or they die a natural death. After performing
whatever one-time initialization it needs, the script enters a
loop waiting for incoming connections, processing the request, and
waiting some more.
A typical FastCGI script will look like this:
#!perl
use CGI::Fast;
do_some_initialization();
while ($q = CGI::Fast->new) {
process_request($q);
}
Each time there's a new request, CGI::Fast returns a
CGI object to your loop. The rest of the time your script
waits in the call to new(). When the server requests that
your script be terminated, new() will return undef. You can
of course exit earlier if you choose. A new version of the
script will be respawned to take its place (this may be
necessary in order to avoid Perl memory leaks in long-running
scripts).
CGI.pm's default CGI object mode also works. Just modify the loop
this way:
while (CGI::Fast->new) {
process_request();
}
Calls to header(), start\_form(), etc. will all operate on the
current request.
# INSTALLING FASTCGI SCRIPTS
See the FastCGI developer's kit documentation for full details. On
the Apache server, the following line must be added to srm.conf:
AddType application/x-httpd-fcgi .fcgi
FastCGI scripts must end in the extension .fcgi. For each script you
install, you must add something like the following to srm.conf:
FastCgiServer /usr/etc/httpd/fcgi-bin/file_upload.fcgi -processes 2
This instructs Apache to launch two copies of file\_upload.fcgi at
startup time.
# USING FASTCGI SCRIPTS AS CGI SCRIPTS
Any script that works correctly as a FastCGI script will also work
correctly when installed as a vanilla CGI script. However it will
not see any performance benefit.
# EXTERNAL FASTCGI SERVER INVOCATION
FastCGI supports a TCP/IP transport mechanism which allows FastCGI scripts to run
external to the webserver, perhaps on a remote machine. To configure the
webserver to connect to an external FastCGI server, you would add the following
to your srm.conf:
FastCgiExternalServer /usr/etc/httpd/fcgi-bin/file_upload.fcgi -host sputnik:8888
Two environment variables affect how the `CGI::Fast` object is created,
allowing `CGI::Fast` to be used as an external FastCGI server. (See `FCGI`
documentation for `FCGI::OpenSocket` for more information.)
You can set these as ENV variables or imports in the use CGI::Fast statement.
If the ENV variables are set then these will be favoured so you can override
the import statements on the command line, etc.
- FCGI\_SOCKET\_PATH / socket\_path
The address (TCP/IP) or path (UNIX Domain) of the socket the external FastCGI
script to which bind an listen for incoming connections from the web server.
- FCGI\_SOCKET\_PERM / socket\_perm
Permissions for UNIX Domain socket.
- FCGI\_LISTEN\_QUEUE / listen\_queue
Maximum length of the queue of pending connections, defaults to 100.
For example:
use CGI::Fast
socket_path => "sputnik:8888",
listen_queue => "50"
;
use CGI qw/ :standard /;
do_some_initialization();
while ($q = CGI::Fast->new) {
process_request($q);
}
Or:
use CGI::Fast;
use CGI qw/ :standard /;
do_some_initialization();
$ENV{FCGI_SOCKET_PATH} = "sputnik:8888";
$ENV{FCGI_LISTEN_QUEUE} = 50;
while ($q = CGI::Fast->new) {
process_request($q);
}
Note the importance of having use CGI after use CGI::Fast as this will
prevent any CGI import pragmas being overwritten by CGI::Fast. You can
use CGI::Fast as a drop in replacement like so:
use CGI::Fast qw/ :standard /
# FILE HANDLES
FCGI defaults to using STDOUT and STDERR as its output filehandles - this
may lead to unexpected redirect of output if you migrate scripts from CGI.pm
to CGI::Fast. To get around this you can use the file\_handles method, which
you must do **before** the first call to CGI::Fast->new. For example using
IO::Handle:
CGI::Fast->file_handles({
fcgi_output_file_handle => IO::Handle->new,
fcgi_error_file_handle => IO::Handle->new,
});
while (CGI::Fast->new) {
..
}
Overriding STDIN using the `fcgi_input_file_handle` key is also possible,
however doing so is likely to break at least POST requests.
# CAVEATS
I haven't tested this very much.
# LICENSE
Copyright 1996-1998, Lincoln D. Stein. All rights reserved. Currently
maintained by Lee Johnson
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
Address bug reports and comments to:
https://github.com/leejo/cgi-fast
# BUGS
This section intentionally left blank.
# SEE ALSO
[CGI::Carp](https://metacpan.org/pod/CGI::Carp), [CGI](https://metacpan.org/pod/CGI)
CGI-Fast-2.13/lib/ 000755 000765 000120 00000000000 13203506565 015000 5 ustar 00leejohnson admin 000000 000000 CGI-Fast-2.13/t/ 000755 000765 000120 00000000000 13203506565 014475 5 ustar 00leejohnson admin 000000 000000 CGI-Fast-2.13/t/001_basic.t 000644 000765 000120 00000001550 13015042333 016311 0 ustar 00leejohnson admin 000000 000000 #!perl -w
my $fcgi;
use CGI::Fast;
use Test::More tests => 9;
# Shut up "used only once" warnings.
() = $CGI::Q;
ok( my $q = CGI::Fast->new(), 'created new CGI::Fast object' );
is( $q, $CGI::Q, 'checking to see if the object was stored properly' );
is( $q->param(), (), 'no params' );
ok( $q = CGI::Fast->new({ foo => 'bar' }), 'creating object with params' );
is( $q->param('foo'), 'bar', 'checking passed param' );
is($CGI::HEADERS_ONCE,0, "reality check default value for CGI::HEADERS_ONCE++");
import CGI::Fast '-unique_headers';
CGI::Fast->new;
is($CGI::HEADERS_ONCE,1, "pragma in subclass set package variable in parent class. ");
$q = CGI::Fast->new({ a => 1 });
ok($q, "reality check: something was returned from CGI::Fast->new besides undef");
is($CGI::HEADERS_ONCE,1, "package variable in parent class persists through multiple calls to CGI::Fast->new ");
CGI-Fast-2.13/t/002_import.t 000644 000765 000120 00000001140 13015042333 016536 0 ustar 00leejohnson admin 000000 000000 #!perl -w
my $fcgi;
BEGIN {
local $@;
eval { require FCGI };
$fcgi = $@ ? 0 : 1;
}
use Test::More tests => 3;
# Shut up "used only once" warnings.
() = $CGI::Q;
SKIP: {
skip( 'FCGI not installed, cannot continue', 2 ) unless $fcgi;
use CGI::Fast
'-unique_headers',
socket_path => ':9000',
listen_queue => 50
;
is( $CGI::Fast::socket,':9000','imported socket_path' );
is( $CGI::Fast::queue,50,'imported listen_queue' );
is(
$CGI::HEADERS_ONCE,
1,
"pragma in subclass set package variable in parent class. "
);
};
CGI-Fast-2.13/t/003_env_pollution.t 000644 000765 000120 00000003216 13203506072 020134 0 ustar 00leejohnson admin 000000 000000 #!perl
use strict;
use warnings;
use Test::More tests => 18;
use CGI::Fast socket_path => ":7070";
# override FCGI::Accept method to get none-blocking behaviour
# all we're interested in is having an FCGI::Request object
# that has been instantiated with the ENV hash
no warnings 'redefine';
no warnings 'prototype';
*FCGI::Accept = sub { 1 };
# fake up an ENV containing some CGI specific variables that
# will get passed into FCGI::Request on the instantiation
$ENV{$_} = $_
for qw(REMOTE_ADDR HTTP_COOKIE PATH_INFO QUERY_STRING);
foreach my $i ( 1 .. 5 ) {
# first loop will instantiate FCGI::Request object
# second loop needs an initialiser as ->Accept will
# return -1 so the call to ->new will return undef
my $q = CGI::Fast->new;
# even requests will contain empty ENV
if ( $i % 2 == 0 ) {
delete( $ENV{$_} )
for qw(REMOTE_ADDR HTTP_COOKIE PATH_INFO QUERY_STRING);
} else {
$ENV{$_} = $_
for qw(REMOTE_ADDR HTTP_COOKIE PATH_INFO QUERY_STRING);
}
my $cgi_vars = {
map { $_ => $q->$_ }
qw/remote_addr raw_cookie path_info query_string/
};
if ( $i % 2 == 0 ) {
is( $cgi_vars->{$_},'','ENV variables not reused from last request' )
for qw/ raw_cookie path_info query_string /;
} else {
is( $cgi_vars->{remote_addr},'REMOTE_ADDR','ENV variables set from current environment' );
is( $cgi_vars->{raw_cookie},'HTTP_COOKIE','ENV variables set from current environment' );
is( $cgi_vars->{path_info},'PATH_INFO','ENV variables set from current environment' );
is( $cgi_vars->{query_string},'','ENV variables set from current environment' );
}
}
CGI-Fast-2.13/t/004_fcgi_file_handles.t 000644 000765 000120 00000001263 13015042333 020641 0 ustar 00leejohnson admin 000000 000000 #!perl
use strict;
use warnings;
use Test::More tests => 4;
use CGI::Fast;
# oook oook! monkey patching to mock FCGI behaviour
no warnings 'redefine';
no warnings 'once';
no warnings 'prototype';
*Accept = sub { 1 };
*FCGI::Request = sub {
# check we actually pass file handles to FCGI::Request
is( $_,'some file handle','file handle passed to FCGI' )
foreach @_[0..2];
return bless({});
};
CGI::Fast->file_handles({
# really here you would use IO::Handle or some equivalent
fcgi_input_file_handle => 'some file handle',
fcgi_output_file_handle => 'some file handle',
fcgi_error_file_handle => 'some file handle',
});
ok( my $q = CGI::Fast->new,'CGI::Fast->new' );
CGI-Fast-2.13/t/005_no_file_handles.t 000644 000765 000120 00000000704 13015042333 020345 0 ustar 00leejohnson admin 000000 000000 #!perl
use strict;
use warnings;
use Test::More tests => 4;
use CGI::Fast;
# oook oook! monkey patching to mock FCGI behaviour
no warnings 'redefine';
no warnings 'once';
no warnings 'prototype';
*Accept = sub { 1 };
*FCGI::Request = sub {
# check we actually pass file handles to FCGI::Request
isa_ok( $_,'GLOB','no file handle passed to FCGI' )
foreach @_[0..2];
return bless({});
};
ok( my $q = CGI::Fast->new,'CGI::Fast->new' );
CGI-Fast-2.13/t/006_changes.t 000644 000765 000120 00000000251 13015042333 016642 0 ustar 00leejohnson admin 000000 000000 #!perl
use strict;
use warnings;
use Test::More;
eval 'use Test::CPAN::Changes';
plan skip_all => 'Test::CPAN::Changes required for this test' if $@;
changes_ok();
CGI-Fast-2.13/t/007_socket_perm.t 000644 000765 000120 00000002135 13015042333 017551 0 ustar 00leejohnson admin 000000 000000 #!perl
use warnings;
use strict;
use Test::More;
use CGI::Fast;
use File::Temp;
my $OS;
unless ($OS = $^O) {
require Config;
$OS = $Config::Config{'osname'};
}
if ( $OS =~ /^MSWin/i ) {
plan skip_all => "valid on unix-y servers only";
}
{ no warnings 'redefine'; sub FCGI::Accept ($) {} }
my $fh = File::Temp->new;
my $f = $fh->filename;
undef( $fh );
import CGI::Fast socket_path => $f;
ok( !-e $f, 'socket not exists' );
CGI::Fast->new();
ok( -e $f, 'socket was created' );
is( 0777 & (stat $f)[2], 0777 & ~umask, 'socket has default perms' );
unlink $f;
undef $CGI::Fast::Ext_Request;
import CGI::Fast socket_perm => 0777;
ok( !-e $f, 'socket not exists' );
CGI::Fast->new();
ok( -e $f, 'socket was created' );
is( 0777 & (stat $f)[2], 0777, 'socket has given perms' );
unlink $f;
undef $CGI::Fast::Ext_Request;
import CGI::Fast socket_perm => 0777;
ok( !-e $f, 'socket not exists' );
$ENV{FCGI_SOCKET_PERM} = 0666;
CGI::Fast->new();
ok( -e $f, 'socket was created' );
is( 0777 & (stat $f)[2], 0666, '$FCGI_SOCKET_PERM has higher priority' );
unlink $f;
undef $CGI::Fast::Ext_Request;
done_testing();
CGI-Fast-2.13/lib/CGI/ 000755 000765 000120 00000000000 13203506565 015402 5 ustar 00leejohnson admin 000000 000000 CGI-Fast-2.13/lib/CGI/Fast.pm 000644 000765 000120 00000021612 13203506360 016630 0 ustar 00leejohnson admin 000000 000000 package CGI::Fast;
use strict;
use warnings;
use if $] >= 5.019, 'deprecate';
$CGI::Fast::VERSION='2.13';
use CGI;
use CGI::Carp;
use FCGI;
# use vars works like "our", but is compatible with older Perls.
use vars qw(
@ISA
$ignore
);
@ISA = ('CGI');
# workaround for known bug in libfcgi
while (($ignore) = each %ENV) { }
# override the initialization behavior so that
# state is NOT maintained between invocations
sub save_request {
# no-op
}
# If ENV{FCGI_SOCKET_PATH} is specified, we maintain a FCGI Request handle
# in this package variable.
use vars qw($Ext_Request $socket $socket_perm $queue);
sub import {
my ($package,@import) = @_;
# check imports for this class then pass on
# imports to SUPER class
for (my $i = 0; $i < scalar( @import ); $i++) {
if ( $import[$i] eq 'socket_path' ) {
$socket = $import[$i+1];
} elsif ( $import[$i] eq 'socket_perm' ) {
$socket_perm = $import[$i+1];
} elsif ( $import[$i] eq 'listen_queue' ) {
$queue = $import[$i+1];
}
}
$package->SUPER::import(@import);
}
sub _create_fcgi_request {
my ( $in_fh,$out_fh,$err_fh ) = @_;
# If we have a socket set, explicitly open it
if ($ENV{FCGI_SOCKET_PATH} or $socket) {
my $path = $ENV{FCGI_SOCKET_PATH} || $socket;
my $perm = $ENV{FCGI_SOCKET_PERM} || $socket_perm;
my $backlog = $ENV{FCGI_LISTEN_QUEUE} || $queue || 100;
my $socket = FCGI::OpenSocket( $path, $backlog );
if ($path !~ /^:/ && defined $perm) {
chmod $perm, $path or croak( "Couldn't chmod($path): $!" );
}
return FCGI::Request(
( $in_fh || \*STDIN ),
( $out_fh || \*STDOUT ),
( $err_fh || \*STDERR ),
\%ENV,
$socket,
1
);
}
else {
return FCGI::Request(
( $in_fh || \*STDIN ),
( $out_fh || \*STDOUT ),
( $err_fh || \*STDERR ),
);
}
}
{
my ( $in_fh,$out_fh,$err_fh );
sub file_handles {
my ($self, $handles) = @_;
if ( ref( $handles ) eq 'HASH' ) {
$in_fh = delete( $handles->{fcgi_input_file_handle} );
$out_fh = delete( $handles->{fcgi_output_file_handle} );
$err_fh = delete( $handles->{fcgi_error_file_handle} );
}
}
sub new {
my ($self, $initializer, @param) = @_;
if ( ! defined $initializer ) {
$Ext_Request ||= _create_fcgi_request( $in_fh,$out_fh,$err_fh );
return undef unless $Ext_Request->Accept >= 0;
}
CGI->_reset_globals;
$self->_setup_symbols(@CGI::SAVED_SYMBOLS) if @CGI::SAVED_SYMBOLS;
return $CGI::Q = $self->SUPER::new($initializer, @param);
}
}
1;
=head1 NAME
CGI::Fast - CGI Interface for Fast CGI
=for html
=head1 SYNOPSIS
use CGI::Fast
socket_path => '9000',
socket_perm => 0777,
listen_queue => 50;
use CGI qw/ :standard /;
$COUNTER = 0;
# optional, will default to STDOUT, STDERR
CGI::Fast->file_handles({
fcgi_output_file_handle => IO::Handle->new,
fcgi_error_file_handle => IO::Handle->new,
});
while ($q = CGI::Fast->new) {
process_request($q);
}
=head1 DESCRIPTION
CGI::Fast is a subclass of the CGI object created by CGI.pm. It is
specialized to work with the FCGI module, which greatly speeds up CGI
scripts by turning them into persistently running server processes.
Scripts that perform time-consuming initialization processes, such as
loading large modules or opening persistent database connections, will
see large performance improvements.
=head1 OTHER PIECES OF THE PUZZLE
In order to use CGI::Fast you'll need the FCGI module. See
http://www.cpan.org/ for details.
=head1 WRITING FASTCGI PERL SCRIPTS
FastCGI scripts are persistent: one or more copies of the script
are started up when the server initializes, and stay around until
the server exits or they die a natural death. After performing
whatever one-time initialization it needs, the script enters a
loop waiting for incoming connections, processing the request, and
waiting some more.
A typical FastCGI script will look like this:
#!perl
use CGI::Fast;
do_some_initialization();
while ($q = CGI::Fast->new) {
process_request($q);
}
Each time there's a new request, CGI::Fast returns a
CGI object to your loop. The rest of the time your script
waits in the call to new(). When the server requests that
your script be terminated, new() will return undef. You can
of course exit earlier if you choose. A new version of the
script will be respawned to take its place (this may be
necessary in order to avoid Perl memory leaks in long-running
scripts).
CGI.pm's default CGI object mode also works. Just modify the loop
this way:
while (CGI::Fast->new) {
process_request();
}
Calls to header(), start_form(), etc. will all operate on the
current request.
=head1 INSTALLING FASTCGI SCRIPTS
See the FastCGI developer's kit documentation for full details. On
the Apache server, the following line must be added to srm.conf:
AddType application/x-httpd-fcgi .fcgi
FastCGI scripts must end in the extension .fcgi. For each script you
install, you must add something like the following to srm.conf:
FastCgiServer /usr/etc/httpd/fcgi-bin/file_upload.fcgi -processes 2
This instructs Apache to launch two copies of file_upload.fcgi at
startup time.
=head1 USING FASTCGI SCRIPTS AS CGI SCRIPTS
Any script that works correctly as a FastCGI script will also work
correctly when installed as a vanilla CGI script. However it will
not see any performance benefit.
=head1 EXTERNAL FASTCGI SERVER INVOCATION
FastCGI supports a TCP/IP transport mechanism which allows FastCGI scripts to run
external to the webserver, perhaps on a remote machine. To configure the
webserver to connect to an external FastCGI server, you would add the following
to your srm.conf:
FastCgiExternalServer /usr/etc/httpd/fcgi-bin/file_upload.fcgi -host sputnik:8888
Two environment variables affect how the C object is created,
allowing C to be used as an external FastCGI server. (See C
documentation for C for more information.)
You can set these as ENV variables or imports in the use CGI::Fast statement.
If the ENV variables are set then these will be favoured so you can override
the import statements on the command line, etc.
=over
=item FCGI_SOCKET_PATH / socket_path
The address (TCP/IP) or path (UNIX Domain) of the socket the external FastCGI
script to which bind an listen for incoming connections from the web server.
=item FCGI_SOCKET_PERM / socket_perm
Permissions for UNIX Domain socket.
=item FCGI_LISTEN_QUEUE / listen_queue
Maximum length of the queue of pending connections, defaults to 100.
=back
For example:
use CGI::Fast
socket_path => "sputnik:8888",
listen_queue => "50"
;
use CGI qw/ :standard /;
do_some_initialization();
while ($q = CGI::Fast->new) {
process_request($q);
}
Or:
use CGI::Fast;
use CGI qw/ :standard /;
do_some_initialization();
$ENV{FCGI_SOCKET_PATH} = "sputnik:8888";
$ENV{FCGI_LISTEN_QUEUE} = 50;
while ($q = CGI::Fast->new) {
process_request($q);
}
Note the importance of having use CGI after use CGI::Fast as this will
prevent any CGI import pragmas being overwritten by CGI::Fast. You can
use CGI::Fast as a drop in replacement like so:
use CGI::Fast qw/ :standard /
=head1 FILE HANDLES
FCGI defaults to using STDOUT and STDERR as its output filehandles - this
may lead to unexpected redirect of output if you migrate scripts from CGI.pm
to CGI::Fast. To get around this you can use the file_handles method, which
you must do B the first call to CGI::Fast->new. For example using
IO::Handle:
CGI::Fast->file_handles({
fcgi_output_file_handle => IO::Handle->new,
fcgi_error_file_handle => IO::Handle->new,
});
while (CGI::Fast->new) {
..
}
Overriding STDIN using the C key is also possible,
however doing so is likely to break at least POST requests.
=head1 CAVEATS
I haven't tested this very much.
=head1 LICENSE
Copyright 1996-1998, Lincoln D. Stein. All rights reserved. Currently
maintained by Lee Johnson
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
Address bug reports and comments to:
https://github.com/leejo/cgi-fast
=head1 BUGS
This section intentionally left blank.
=head1 SEE ALSO
L, L
=cut