package Catalyst::Engine::FastCGI;
use strict;
-use base qw(Catalyst::Engine::FastCGI::Base Catalyst::Engine::CGI);
+use base 'Catalyst::Engine::CGI';
+eval "use FCGI";
+die "Unable to load the FCGI module, you may need to install it:\n$@\n" if $@;
=head1 NAME
-Catalyst::Engine::FastCGI - Catalyst FastCGI Engine
+Catalyst::Engine::FastCGI - FastCGI Engine
-=head1 SYNOPSIS
+=head1 DESCRIPTION
-A script using the Catalyst::Engine::FastCGI module might look like:
+This is the FastCGI engine.
- #!/usr/bin/perl -w
+=head1 OVERLOADED METHODS
- BEGIN {
- $ENV{CATALYST_ENGINE} = 'FastCGI';
- }
+This class overloads some methods from C<Catalyst::Engine::CGI>.
- use strict;
- use lib '/path/to/MyApp/lib';
- use MyApp;
+=head2 $self->run($c, $listen, { option => value, ... })
+
+Starts the FastCGI server. If C<$listen> is set, then it specifies a
+location to listen for FastCGI requests;
- MyApp->run;
+=over 4
-=head1 DESCRIPTION
+=item /path
-This is the Catalyst engine for FastCGI.
+listen via Unix sockets on /path
-=head1 OVERLOADED METHODS
+=item :port
+
+listen via TCP on port on all interfaces
-This class overloads some methods from C<Catalyst::Engine::FastCGI::Base>.
+=item hostname:port
+
+listen via TCP on port bound to hostname
+
+=back
+
+Options may also be specified;
=over 4
-=item $c->prepare_body
+=item leave_umask
+
+Set to 1 to disable setting umask to 0 for socket open =item nointr
+
+Do not allow the listener to be interrupted by Ctrl+C
+
+=item nproc
+
+Specify a number of processes for FCGI::ProcManager
+
+=item pidfile
+
+Specify a filename for the pid file
+
+=item manager
+
+Specify a FCGI::ProcManager sub-class
+
+=item detach
+
+Detach from console
+
+=item keep_stderr
+
+Send STDERR to STDOUT instead of the webserver
+
+=back
=cut
-sub prepare_body {
- shift->Catalyst::Engine::CGI::prepare_body(@_);
+sub run {
+ my ( $self, $class, $listen, $options ) = @_;
+
+ my $sock = 0;
+ if ($listen) {
+ my $old_umask = umask;
+ unless ( $options->{leave_umask} ) {
+ umask(0);
+ }
+ $sock = FCGI::OpenSocket( $listen, 100 )
+ or die "failed to open FastCGI socket; $!";
+ unless ( $options->{leave_umask} ) {
+ umask($old_umask);
+ }
+ }
+ elsif ( $^O ne 'MSWin32' ) {
+ -S STDIN
+ or die "STDIN is not a socket; specify a listen location";
+ }
+
+ $options ||= {};
+
+ my %env;
+ my $error = \*STDERR; # send STDERR to the web server
+ $error = \*STDOUT # send STDERR to stdout (a logfile)
+ if $options->{keep_stderr}; # (if asked to)
+
+ my $request =
+ FCGI::Request( \*STDIN, \*STDOUT, $error, \%env, $sock,
+ ( $options->{nointr} ? 0 : &FCGI::FAIL_ACCEPT_ON_INTR ),
+ );
+
+ my $proc_manager;
+
+ if ($listen) {
+ $options->{manager} ||= "FCGI::ProcManager";
+ $options->{nproc} ||= 1;
+
+ $self->daemon_fork() if $options->{detach};
+
+ if ( $options->{manager} ) {
+ eval "use $options->{manager}; 1" or die $@;
+
+ $proc_manager = $options->{manager}->new(
+ {
+ n_processes => $options->{nproc},
+ pid_fname => $options->{pidfile},
+ }
+ );
+
+ # detach *before* the ProcManager inits
+ $self->daemon_detach() if $options->{detach};
+
+ $proc_manager->pm_manage();
+ }
+ elsif ( $options->{detach} ) {
+ $self->daemon_detach();
+ }
+ }
+
+ while ( $request->Accept >= 0 ) {
+ $proc_manager && $proc_manager->pm_pre_dispatch();
+
+ # If we're running under Lighttpd, swap PATH_INFO and SCRIPT_NAME
+ # http://lists.rawmode.org/pipermail/catalyst/2006-June/008361.html
+ # Thanks to Mark Blythe for this fix
+ if ( $env{SERVER_SOFTWARE} && $env{SERVER_SOFTWARE} =~ /lighttpd/ ) {
+ $env{PATH_INFO} ||= delete $env{SCRIPT_NAME};
+ }
+
+ $class->handle_request( env => \%env );
+
+ $proc_manager && $proc_manager->pm_post_dispatch();
+ }
}
-=item $c->prepare_parameters
+=head2 $self->write($c, $buffer)
=cut
-sub prepare_parameters {
- shift->Catalyst::Engine::CGI::prepare_parameters(@_);
+sub write {
+ my ( $self, $c, $buffer ) = @_;
+
+ unless ( $self->{_prepared_write} ) {
+ $self->prepare_write($c);
+ $self->{_prepared_write} = 1;
+ }
+
+ # FastCGI does not stream data properly if using 'print $handle',
+ # but a syswrite appears to work properly.
+ *STDOUT->syswrite($buffer);
}
-=item $c->prepare_request
+=head2 $self->daemon_fork()
+
+Performs the first part of daemon initialisation. Specifically,
+forking. STDERR, etc are still connected to a terminal.
=cut
-sub prepare_request {
- my ( $c, $fastcgi, @arguments ) = @_;
- CGI::_reset_globals();
- $c->SUPER::prepare_request($fastcgi);
- $c->Catalyst::Engine::CGI::prepare_request(@arguments);
+sub daemon_fork {
+ require POSIX;
+ fork && exit;
}
-=item $c->prepare_uploads
+=head2 $self->daemon_detach( )
+
+Performs the second part of daemon initialisation. Specifically,
+disassociates from the terminal.
+
+However, this does B<not> change the current working directory to "/",
+as normal daemons do. It also does not close all open file
+descriptors (except STDIN, STDOUT and STDERR, which are re-opened from
+F</dev/null>).
=cut
-sub prepare_uploads {
- shift->Catalyst::Engine::CGI::prepare_uploads(@_);
+sub daemon_detach {
+ my $self = shift;
+ print "FastCGI daemon started (pid $$)\n";
+ open STDIN, "+</dev/null" or die $!;
+ open STDOUT, ">&STDIN" or die $!;
+ open STDERR, ">&STDIN" or die $!;
+ POSIX::setsid();
}
+1;
+__END__
+
+=head1 WEB SERVER CONFIGURATIONS
+
+=head2 Standalone FastCGI Server
+
+In server mode the application runs as a standalone server and accepts
+connections from a web server. The application can be on the same machine as
+the web server, on a remote machine, or even on multiple remote machines.
+Advantages of this method include running the Catalyst application as a
+different user than the web server, and the ability to set up a scalable
+server farm.
+
+To start your application in server mode, install the FCGI::ProcManager
+module and then use the included fastcgi.pl script.
+
+ $ script/myapp_fastcgi.pl -l /tmp/myapp.socket -n 5
+
+Command line options for fastcgi.pl include:
+
+ -d -daemon Daemonize the server.
+ -p -pidfile Write a pidfile with the pid of the process manager.
+ -l -listen Listen on a socket path, hostname:port, or :port.
+ -n -nproc The number of processes started to handle requests.
+
+See below for the specific web server configurations for using the external
+server.
+
+=head2 Apache 1.x, 2.x
+
+Apache requires the mod_fastcgi module. The same module supports both
+Apache 1 and 2.
+
+There are three ways to run your application under FastCGI on Apache: server,
+static, and dynamic.
+
+=head3 Standalone server mode
+
+ FastCgiExternalServer /tmp/myapp.fcgi -socket /tmp/myapp.socket
+ Alias /myapp/ /tmp/myapp/myapp.fcgi/
+
+ # Or, run at the root
+ Alias / /tmp/myapp.fcgi/
+
+ # Optionally, rewrite the path when accessed without a trailing slash
+ RewriteRule ^/myapp$ myapp/ [R]
+
+
+The FastCgiExternalServer directive tells Apache that when serving
+/tmp/myapp to use the FastCGI application listenting on the socket
+/tmp/mapp.socket. Note that /tmp/myapp.fcgi does not need to exist --
+it's a virtual file name. With some versions of C<mod_fastcgi> or
+C<mod_fcgid>, you can use any name you like, but most require that the
+virtual filename end in C<.fcgi>.
+
+It's likely that Apache is not configured to serve files in /tmp, so the
+Alias directive maps the url path /myapp/ to the (virtual) file that runs the
+FastCGI application. The trailing slashes are important as their use will
+correctly set the PATH_INFO environment variable used by Catalyst to
+determine the request path. If you would like to be able to access your app
+without a trailing slash (http://server/myapp), you can use the above
+RewriteRule directive.
+
+=head3 Static mode
+
+The term 'static' is misleading, but in static mode Apache uses its own
+FastCGI Process Manager to start the application processes. This happens at
+Apache startup time. In this case you do not run your application's
+fastcgi.pl script -- that is done by Apache. Apache then maps URIs to the
+FastCGI script to run your application.
+
+ FastCgiServer /path/to/myapp/script/myapp_fastcgi.pl -processes 3
+ Alias /myapp/ /path/to/myapp/script/myapp_fastcgi.pl/
+
+FastCgiServer tells Apache to start three processes of your application at
+startup. The Alias command maps a path to the FastCGI application. Again,
+the trailing slashes are important.
+
+=head3 Dynamic mode
+
+In FastCGI dynamic mode, Apache will run your application on demand,
+typically by requesting a file with a specific extension (e.g. .fcgi). ISPs
+often use this type of setup to provide FastCGI support to many customers.
+
+In this mode it is often enough to place or link your *_fastcgi.pl script in
+your cgi-bin directory with the extension of .fcgi. In dynamic mode Apache
+must be able to run your application as a CGI script so ExecCGI must be
+enabled for the directory.
+
+ AddHandler fastcgi-script .fcgi
+
+The above tells Apache to run any .fcgi file as a FastCGI application.
+
+Here is a complete example:
+
+ <VirtualHost *:80>
+ ServerName www.myapp.com
+ DocumentRoot /path/to/MyApp
+
+ # Allow CGI script to run
+ <Directory /path/to/MyApp>
+ Options +ExecCGI
+ </Directory>
+
+ # Tell Apache this is a FastCGI application
+ <Files myapp_fastcgi.pl>
+ SetHandler fastcgi-script
+ </Files>
+ </VirtualHost>
+
+Then a request for /script/myapp_fastcgi.pl will run the
+application.
+
+For more information on using FastCGI under Apache, visit
+L<http://www.fastcgi.com/mod_fastcgi/docs/mod_fastcgi.html>
+
+=head2 Lighttpd
+
+These configurations were tested with Lighttpd 1.4.7.
+
+=head3 Standalone server mode
+
+ server.document-root = "/var/www/MyApp/root"
+
+ fastcgi.server = (
+ "" => (
+ "MyApp" => (
+ "socket" => "/tmp/myapp.socket",
+ "check-local" => "disable"
+ )
+ )
+ )
+
+=head3 Static mode
+
+ server.document-root = "/var/www/MyApp/root"
+
+ fastcgi.server = (
+ "" => (
+ "MyApp" => (
+ "socket" => "/tmp/myapp.socket",
+ "check-local" => "disable",
+ "bin-path" => "/var/www/MyApp/script/myapp_fastcgi.pl",
+ "min-procs" => 2,
+ "max-procs" => 5,
+ "idle-timeout" => 20
+ )
+ )
+ )
+
+Note that in newer versions of lighttpd, the min-procs and idle-timeout
+values are disabled. The above example would start 5 processes.
+
+=head3 Non-root configuration
+
+You can also run your application at any non-root location with either of the
+above modes.
+
+ fastcgi.server = (
+ "/myapp" => (
+ "MyApp" => (
+ # same as above
+ )
+ )
+ )
+
+For more information on using FastCGI under Lighttpd, visit
+L<http://www.lighttpd.net/documentation/fastcgi.html>
+
+=head2 IIS
+
+It is possible to run Catalyst under IIS with FastCGI, but we do not
+yet have detailed instructions.
+
=head1 SEE ALSO
-L<Catalyst>, L<Catalyst::Engine::FastCGI::Base>, L<Catalyst::Engine::CGI>.
+L<Catalyst>, L<FCGI>.
-=head1 AUTHOR
+=head1 AUTHORS
-Sebastian Riedel, C<sri@cpan.org>
-Christian Hansen, C<ch@ngmedia.com>
+Sebastian Riedel, <sri@cpan.org>
+
+Christian Hansen, <ch@ngmedia.com>
+
+Andy Grundman, <andy@hybridized.org>
+
+=head1 THANKS
+
+Bill Moseley, for documentation updates and testing.
=head1 COPYRIGHT
the same terms as Perl itself.
=cut
-
-1;
projects / catagits/Catalyst-Runtime.git / blobdiff