X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Runtime.git;a=blobdiff_plain;f=lib%2FCatalyst%2FEngine%2FFastCGI.pm;h=397bdc061c2f48390fe5c0a2acb6257d698a8ac7;hp=506927b0b742175ac3e7931f17db894be5c2a261;hb=6f1f968a6bc42bf4a4b50a1ee22d3aaecd801876;hpb=895b2303b18c8761c46a9e0190b254594ec40654 diff --git a/lib/Catalyst/Engine/FastCGI.pm b/lib/Catalyst/Engine/FastCGI.pm index 506927b..397bdc0 100644 --- a/lib/Catalyst/Engine/FastCGI.pm +++ b/lib/Catalyst/Engine/FastCGI.pm @@ -1,84 +1,416 @@ package Catalyst::Engine::FastCGI; -use strict; -use base qw(Catalyst::Engine::FastCGI::Base Catalyst::Engine::CGI); +use MRO::Compat; +use mro 'c3'; +use Moose; +extends 'Catalyst::Engine::CGI'; + +# eval { Class::MOP::load_class("FCGI") }; +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. - 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 -This class overloads some methods from C -and C. +listen via TCP on port on all interfaces + +=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; + } + + # XXX: We can't use Engine's write() method because syswrite + # appears to return bogus values instead of the number of bytes + # written: http://www.fastcgi.com/om_archive/mail-archive/0128.html + + # Prepend the headers if they have not yet been sent + if ( my $headers = delete $self->{_header_buf} ) { + $buffer = $headers . $buffer; + } + + # 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, $request, @arguments ) = @_; - CGI::_reset_globals(); - $c->SUPER::prepare_request($request); - $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 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). =cut -sub prepare_uploads { - shift->Catalyst::Engine::CGI::prepare_uploads(@_); +sub daemon_detach { + my $self = shift; + print "FastCGI daemon started (pid $$)\n"; + open STDIN, "+&STDIN" or die $!; + open STDERR, ">&STDIN" or die $!; + POSIX::setsid(); } -=back +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 or +C, 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: + + + ServerName www.myapp.com + DocumentRoot /path/to/MyApp + + # Allow CGI script to run + + Options +ExecCGI + + + # Tell Apache this is a FastCGI application + + SetHandler fastcgi-script + + + +Then a request for /script/myapp_fastcgi.pl will run the +application. + +For more information on using FastCGI under Apache, visit +L + +=head3 Authorization header with mod_fastcgi or mod_cgi + +By default, mod_fastcgi/mod_cgi do not pass along the Authorization header, +so modules like C will +not work. To enable pass-through of this header, add the following +mod_rewrite directives: + + RewriteCond %{HTTP:Authorization} ^(.+) + RewriteRule ^(.*)$ $1 [E=HTTP_AUTHORIZATION:%1,PT] + +=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 + +=head2 IIS + +It is possible to run Catalyst under IIS with FastCGI, but we do not +yet have detailed instructions. =head1 SEE ALSO -L, L, L. +L, L. -=head1 AUTHOR +=head1 AUTHORS -Sebastian Riedel, C -Christian Hansen, C +Sebastian Riedel, + +Christian Hansen, + +Andy Grundman, + +=head1 THANKS + +Bill Moseley, for documentation updates and testing. =head1 COPYRIGHT @@ -86,5 +418,3 @@ This program is free software, you can redistribute it and/or modify it under the same terms as Perl itself. =cut - -1;