lib/Catalyst/Engine/FastCGI.pm

   1 package Catalyst::Engine::FastCGI;
   2
   3 use Class::C3;
   4 use Moose;
   5 extends 'Catalyst::Engine::CGI';
   6
   7 # eval { Class::MOP::load_class("FCGI") };
   8 eval "use FCGI";
   9 die "Unable to load the FCGI module, you may need to install it:\n$@\n" if $@;
  10
  11 =head1 NAME
  12
  13 Catalyst::Engine::FastCGI - FastCGI Engine
  14
  15 =head1 DESCRIPTION
  16
  17 This is the FastCGI engine.
  18
  19 =head1 OVERLOADED METHODS
  20
  21 This class overloads some methods from C<Catalyst::Engine::CGI>.
  22
  23 =head2 $self->run($c, $listen, { option => value, ... })
  24
  25 Starts the FastCGI server.  If C<$listen> is set, then it specifies a
  26 location to listen for FastCGI requests;
  27
  28 =over 4
  29
  30 =item /path
  31
  32 listen via Unix sockets on /path
  33
  34 =item :port
  35
  36 listen via TCP on port on all interfaces
  37
  38 =item hostname:port
  39
  40 listen via TCP on port bound to hostname
  41
  42 =back
  43
  44 Options may also be specified;
  45
  46 =over 4
  47
  48 =item leave_umask
  49
  50 Set to 1 to disable setting umask to 0 for socket open =item nointr
  51
  52 Do not allow the listener to be interrupted by Ctrl+C
  53
  54 =item nproc
  55
  56 Specify a number of processes for FCGI::ProcManager
  57
  58 =item pidfile
  59
  60 Specify a filename for the pid file
  61
  62 =item manager
  63
  64 Specify a FCGI::ProcManager sub-class
  65
  66 =item detach
  67
  68 Detach from console
  69
  70 =item keep_stderr
  71
  72 Send STDERR to STDOUT instead of the webserver
  73
  74 =back
  75
  76 =cut
  77
  78 sub run {
  79     my ( $self, $class, $listen, $options ) = @_;
  80
  81     my $sock = 0;
  82     if ($listen) {
  83         my $old_umask = umask;
  84         unless ( $options->{leave_umask} ) {
  85             umask(0);
  86         }
  87         $sock = FCGI::OpenSocket( $listen, 100 )
  88           or die "failed to open FastCGI socket; $!";
  89         unless ( $options->{leave_umask} ) {
  90             umask($old_umask);
  91         }
  92     }
  93     elsif ( $^O ne 'MSWin32' ) {
  94         -S STDIN
  95           or die "STDIN is not a socket; specify a listen location";
  96     }
  97
  98     $options ||= {};
  99
 100     my %env;
 101     my $error = \*STDERR; # send STDERR to the web server
 102        $error = \*STDOUT  # send STDERR to stdout (a logfile)
 103          if $options->{keep_stderr}; # (if asked to)
 104
 105     my $request =
 106       FCGI::Request( \*STDIN, \*STDOUT, $error, \%env, $sock,
 107         ( $options->{nointr} ? 0 : &FCGI::FAIL_ACCEPT_ON_INTR ),
 108       );
 109
 110     my $proc_manager;
 111
 112     if ($listen) {
 113         $options->{manager} ||= "FCGI::ProcManager";
 114         $options->{nproc}   ||= 1;
 115
 116         $self->daemon_fork() if $options->{detach};
 117
 118         if ( $options->{manager} ) {
 119             eval "use $options->{manager}; 1" or die $@;
 120
 121             $proc_manager = $options->{manager}->new(
 122                 {
 123                     n_processes => $options->{nproc},
 124                     pid_fname   => $options->{pidfile},
 125                 }
 126             );
 127
 128             # detach *before* the ProcManager inits
 129             $self->daemon_detach() if $options->{detach};
 130
 131             $proc_manager->pm_manage();
 132         }
 133         elsif ( $options->{detach} ) {
 134             $self->daemon_detach();
 135         }
 136     }
 137
 138     while ( $request->Accept >= 0 ) {
 139         $proc_manager && $proc_manager->pm_pre_dispatch();
 140
 141         # If we're running under Lighttpd, swap PATH_INFO and SCRIPT_NAME
 142         # http://lists.rawmode.org/pipermail/catalyst/2006-June/008361.html
 143         # Thanks to Mark Blythe for this fix
 144         if ( $env{SERVER_SOFTWARE} && $env{SERVER_SOFTWARE} =~ /lighttpd/ ) {
 145             $env{PATH_INFO} ||= delete $env{SCRIPT_NAME};
 146         }
 147
 148         $class->handle_request( env => \%env );
 149
 150         $proc_manager && $proc_manager->pm_post_dispatch();
 151     }
 152 }
 153
 154 =head2 $self->write($c, $buffer)
 155
 156 =cut
 157
 158 sub write {
 159     my ( $self, $c, $buffer ) = @_;
 160
 161     unless ( $self->{_prepared_write} ) {
 162         $self->prepare_write($c);
 163         $self->{_prepared_write} = 1;
 164     }
 165
 166     # XXX: We can't use Engine's write() method because syswrite
 167     # appears to return bogus values instead of the number of bytes
 168     # written: http://www.fastcgi.com/om_archive/mail-archive/0128.html
 169
 170     # Prepend the headers if they have not yet been sent
 171     if ( my $headers = delete $self->{_header_buf} ) {
 172         $buffer = $headers . $buffer;
 173     }
 174
 175     # FastCGI does not stream data properly if using 'print $handle',
 176     # but a syswrite appears to work properly.
 177     *STDOUT->syswrite($buffer);
 178 }
 179
 180 =head2 $self->daemon_fork()
 181
 182 Performs the first part of daemon initialisation.  Specifically,
 183 forking.  STDERR, etc are still connected to a terminal.
 184
 185 =cut
 186
 187 sub daemon_fork {
 188     require POSIX;
 189     fork && exit;
 190 }
 191
 192 =head2 $self->daemon_detach( )
 193
 194 Performs the second part of daemon initialisation.  Specifically,
 195 disassociates from the terminal.
 196
 197 However, this does B<not> change the current working directory to "/",
 198 as normal daemons do.  It also does not close all open file
 199 descriptors (except STDIN, STDOUT and STDERR, which are re-opened from
 200 F</dev/null>).
 201
 202 =cut
 203
 204 sub daemon_detach {
 205     my $self = shift;
 206     print "FastCGI daemon started (pid $$)\n";
 207     open STDIN,  "+</dev/null" or die $!;
 208     open STDOUT, ">&STDIN"     or die $!;
 209     open STDERR, ">&STDIN"     or die $!;
 210     POSIX::setsid();
 211 }
 212
 213 1;
 214 __END__
 215
 216 =head1 WEB SERVER CONFIGURATIONS
 217
 218 =head2 Standalone FastCGI Server
 219
 220 In server mode the application runs as a standalone server and accepts
 221 connections from a web server.  The application can be on the same machine as
 222 the web server, on a remote machine, or even on multiple remote machines.
 223 Advantages of this method include running the Catalyst application as a
 224 different user than the web server, and the ability to set up a scalable
 225 server farm.
 226
 227 To start your application in server mode, install the FCGI::ProcManager
 228 module and then use the included fastcgi.pl script.
 229
 230     $ script/myapp_fastcgi.pl -l /tmp/myapp.socket -n 5
 231
 232 Command line options for fastcgi.pl include:
 233
 234     -d -daemon     Daemonize the server.
 235     -p -pidfile    Write a pidfile with the pid of the process manager.
 236     -l -listen     Listen on a socket path, hostname:port, or :port.
 237     -n -nproc      The number of processes started to handle requests.
 238
 239 See below for the specific web server configurations for using the external
 240 server.
 241
 242 =head2 Apache 1.x, 2.x
 243
 244 Apache requires the mod_fastcgi module.  The same module supports both
 245 Apache 1 and 2.
 246
 247 There are three ways to run your application under FastCGI on Apache: server,
 248 static, and dynamic.
 249
 250 =head3 Standalone server mode
 251
 252     FastCgiExternalServer /tmp/myapp.fcgi -socket /tmp/myapp.socket
 253     Alias /myapp/ /tmp/myapp/myapp.fcgi/
 254
 255     # Or, run at the root
 256     Alias / /tmp/myapp.fcgi/
 257
 258     # Optionally, rewrite the path when accessed without a trailing slash
 259     RewriteRule ^/myapp$ myapp/ [R]
 260
 261
 262 The FastCgiExternalServer directive tells Apache that when serving
 263 /tmp/myapp to use the FastCGI application listenting on the socket
 264 /tmp/mapp.socket.  Note that /tmp/myapp.fcgi does not need to exist --
 265 it's a virtual file name.  With some versions of C<mod_fastcgi> or
 266 C<mod_fcgid>, you can use any name you like, but most require that the
 267 virtual filename end in C<.fcgi>.
 268
 269 It's likely that Apache is not configured to serve files in /tmp, so the
 270 Alias directive maps the url path /myapp/ to the (virtual) file that runs the
 271 FastCGI application. The trailing slashes are important as their use will
 272 correctly set the PATH_INFO environment variable used by Catalyst to
 273 determine the request path.  If you would like to be able to access your app
 274 without a trailing slash (http://server/myapp), you can use the above
 275 RewriteRule directive.
 276
 277 =head3 Static mode
 278
 279 The term 'static' is misleading, but in static mode Apache uses its own
 280 FastCGI Process Manager to start the application processes.  This happens at
 281 Apache startup time.  In this case you do not run your application's
 282 fastcgi.pl script -- that is done by Apache. Apache then maps URIs to the
 283 FastCGI script to run your application.
 284
 285     FastCgiServer /path/to/myapp/script/myapp_fastcgi.pl -processes 3
 286     Alias /myapp/ /path/to/myapp/script/myapp_fastcgi.pl/
 287
 288 FastCgiServer tells Apache to start three processes of your application at
 289 startup.  The Alias command maps a path to the FastCGI application. Again,
 290 the trailing slashes are important.
 291
 292 =head3 Dynamic mode
 293
 294 In FastCGI dynamic mode, Apache will run your application on demand,
 295 typically by requesting a file with a specific extension (e.g. .fcgi).  ISPs
 296 often use this type of setup to provide FastCGI support to many customers.
 297
 298 In this mode it is often enough to place or link your *_fastcgi.pl script in
 299 your cgi-bin directory with the extension of .fcgi.  In dynamic mode Apache
 300 must be able to run your application as a CGI script so ExecCGI must be
 301 enabled for the directory.
 302
 303     AddHandler fastcgi-script .fcgi
 304
 305 The above tells Apache to run any .fcgi file as a FastCGI application.
 306
 307 Here is a complete example:
 308
 309     <VirtualHost *:80>
 310         ServerName www.myapp.com
 311         DocumentRoot /path/to/MyApp
 312
 313         # Allow CGI script to run
 314         <Directory /path/to/MyApp>
 315             Options +ExecCGI
 316         </Directory>
 317
 318         # Tell Apache this is a FastCGI application
 319         <Files myapp_fastcgi.pl>
 320             SetHandler fastcgi-script
 321         </Files>
 322     </VirtualHost>
 323
 324 Then a request for /script/myapp_fastcgi.pl will run the
 325 application.
 326
 327 For more information on using FastCGI under Apache, visit
 328 L<http://www.fastcgi.com/mod_fastcgi/docs/mod_fastcgi.html>
 329
 330 =head3 Authorization header with mod_fastcgi or mod_cgi
 331
 332 By default, mod_fastcgi/mod_cgi do not pass along the Authorization header,
 333 so modules like C<Catalyst::Plugin::Authentication::Credential::HTTP> will
 334 not work.  To enable pass-through of this header, add the following
 335 mod_rewrite directives:
 336
 337     RewriteCond %{HTTP:Authorization} ^(.+)
 338     RewriteRule ^(.*)$ $1 [E=HTTP_AUTHORIZATION:%1,PT]
 339
 340 =head2 Lighttpd
 341
 342 These configurations were tested with Lighttpd 1.4.7.
 343
 344 =head3 Standalone server mode
 345
 346     server.document-root = "/var/www/MyApp/root"
 347
 348     fastcgi.server = (
 349         "" => (
 350             "MyApp" => (
 351                 "socket"      => "/tmp/myapp.socket",
 352                 "check-local" => "disable"
 353             )
 354         )
 355     )
 356
 357 =head3 Static mode
 358
 359     server.document-root = "/var/www/MyApp/root"
 360
 361     fastcgi.server = (
 362         "" => (
 363             "MyApp" => (
 364                 "socket"       => "/tmp/myapp.socket",
 365                 "check-local"  => "disable",
 366                 "bin-path"     => "/var/www/MyApp/script/myapp_fastcgi.pl",
 367                 "min-procs"    => 2,
 368                 "max-procs"    => 5,
 369                 "idle-timeout" => 20
 370             )
 371         )
 372     )
 373
 374 Note that in newer versions of lighttpd, the min-procs and idle-timeout
 375 values are disabled.  The above example would start 5 processes.
 376
 377 =head3 Non-root configuration
 378
 379 You can also run your application at any non-root location with either of the
 380 above modes.
 381
 382     fastcgi.server = (
 383         "/myapp" => (
 384             "MyApp" => (
 385                 # same as above
 386             )
 387         )
 388     )
 389
 390 For more information on using FastCGI under Lighttpd, visit
 391 L<http://www.lighttpd.net/documentation/fastcgi.html>
 392
 393 =head2 IIS
 394
 395 It is possible to run Catalyst under IIS with FastCGI, but we do not
 396 yet have detailed instructions.
 397
 398 =head1 SEE ALSO
 399
 400 L<Catalyst>, L<FCGI>.
 401
 402 =head1 AUTHORS
 403
 404 Sebastian Riedel, <sri@cpan.org>
 405
 406 Christian Hansen, <ch@ngmedia.com>
 407
 408 Andy Grundman, <andy@hybridized.org>
 409
 410 =head1 THANKS
 411
 412 Bill Moseley, for documentation updates and testing.
 413
 414 =head1 COPYRIGHT
 415
 416 This program is free software, you can redistribute it and/or modify it under
 417 the same terms as Perl itself.
 418
 419 =cut