X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FEngine.pm;h=9a6c287d2c2d3d3d1866ed2848962197e73b5d60;hb=87f504360777193d96945014faa1d058224fcb0e;hp=29a2188489c19bb9614f1e4cc0f2bf6c6de27d11;hpb=4904ee278992db70da965b94627728085b88de54;p=catagits%2FCatalyst-Runtime.git diff --git a/lib/Catalyst/Engine.pm b/lib/Catalyst/Engine.pm index 29a2188..9a6c287 100644 --- a/lib/Catalyst/Engine.pm +++ b/lib/Catalyst/Engine.pm @@ -10,38 +10,29 @@ use HTML::Entities; use HTTP::Body; use HTTP::Headers; use URI::QueryParam; -use Moose::Util::TypeConstraints; use Plack::Loader; -use Plack::Middleware::Conditional; -use Plack::Middleware::ReverseProxy; +use Catalyst::EngineLoader; +use Encode (); +use utf8; use namespace::clean -except => 'meta'; -has env => (is => 'ro', writer => '_set_env', clearer => '_clear_env'); - -# input position and length -has read_length => (is => 'rw'); -has read_position => (is => 'rw'); - -has _prepared_write => (is => 'rw'); - -has _response_cb => ( - is => 'ro', - isa => 'CodeRef', - writer => '_set_response_cb', - clearer => '_clear_response_cb', -); - -has _writer => ( - is => 'ro', - isa => duck_type([qw(write close)]), - writer => '_set_writer', - clearer => '_clear_writer', -); - # Amount of data to read from input on each pass our $CHUNKSIZE = 64 * 1024; +# XXX - this is only here for compat, do not use! +has env => ( is => 'rw', writer => '_set_env' ); +my $WARN_ABOUT_ENV = 0; +around env => sub { + my ($orig, $self, @args) = @_; + if(@args) { + warn "env as a writer is deprecated, you probably need to upgrade Catalyst::Engine::PSGI" + unless $WARN_ABOUT_ENV++; + return $self->_set_env(@args); + } + return $self->$orig; +}; + =head1 NAME Catalyst::Engine - The Catalyst Engine @@ -78,9 +69,9 @@ sub finalize_body { $self->write( $c, $body ); } - $self->_writer->close; - $self->_clear_writer; - $self->_clear_env; + my $res = $c->response; + $res->_writer->close; + $res->_clear_writer; return; } @@ -115,6 +106,11 @@ sub finalize_cookies { -httponly => $val->{httponly} || 0, ) ); + if (!defined $cookie) { + $c->log->warn("undef passed in '$name' cookie value - not setting cookie") + if $c->debug; + next; + } push @cookies, $cookie->as_string; } @@ -155,6 +151,14 @@ sub finalize_error { $c->res->content_type('text/html; charset=utf-8'); my $name = ref($c)->config->{name} || join(' ', split('::', ref $c)); + + # Prevent Catalyst::Plugin::Unicode::Encoding from running. + # This is a little nasty, but it's the best way to be clean whether or + # not the user has an encoding plugin. + + if ($c->can('encoding')) { + $c->{encoding} = ''; + } my ( $title, $error, $infos ); if ( $c->debug ) { @@ -303,11 +307,12 @@ sub finalize_error { - # Trick IE. Old versions of IE would display their own error page instead # of ours if we'd give it less than 512 bytes. $c->res->{body} .= ( ' ' x 512 ); + $c->res->{body} = Encode::encode("UTF-8", $c->res->{body}); + # Return 500 $c->res->status(500); } @@ -321,21 +326,25 @@ Abstract method, allows engines to write headers to response sub finalize_headers { my ($self, $ctx) = @_; + # This is a less-than-pretty hack to avoid breaking the old + # Catalyst::Engine::PSGI. 5.9 Catalyst::Engine sets a response_cb and + # expects us to pass headers to it here, whereas Catalyst::Enngine::PSGI + # just pulls the headers out of $ctx->response in its run method and never + # sets response_cb. So take the lack of a response_cb as a sign that we + # don't need to set the headers. + + return unless ($ctx->response->_has_response_cb); + my @headers; $ctx->response->headers->scan(sub { push @headers, @_ }); - $self->_set_writer($self->_response_cb->([ $ctx->response->status, \@headers ])); - $self->_clear_response_cb; + my $writer = $ctx->response->_response_cb->([ $ctx->response->status, \@headers ]); + $ctx->response->_set_writer($writer); + $ctx->response->_clear_response_cb; return; } -=head2 $self->finalize_read($c) - -=cut - -sub finalize_read { } - =head2 $self->finalize_uploads($c) Clean up after uploads, deleting temp files. @@ -366,8 +375,8 @@ sub prepare_body { my ( $self, $c ) = @_; my $appclass = ref($c) || $c; - if ( my $length = $self->read_length ) { - my $request = $c->request; + my $request = $c->request; + if ( my $length = $request->_read_length ) { unless ( $request->_body ) { my $type = $request->header('Content-Type'); $request->_body(HTTP::Body->new( $type, $length )); @@ -382,9 +391,8 @@ sub prepare_body { } # paranoia against wrong Content-Length header - my $remaining = $length - $self->read_position; + my $remaining = $length - $c->request->_read_position; if ( $remaining > 0 ) { - $self->finalize_read($c); Catalyst::Exception->throw( "Wrong Content-Length value: $length" ); } @@ -430,8 +438,8 @@ Abstract method implemented in engines. sub prepare_connection { my ($self, $ctx) = @_; - my $env = $self->env; my $request = $ctx->request; + my $env = $ctx->request->env; $request->address( $env->{REMOTE_ADDR} ); $request->hostname( $env->{REMOTE_HOST} ) @@ -465,7 +473,7 @@ sub prepare_cookies { sub prepare_headers { my ($self, $ctx) = @_; - my $env = $self->env; + my $env = $ctx->request->env; my $headers = $ctx->request->headers; for my $header (keys %{ $env }) { @@ -515,7 +523,7 @@ abstract method, implemented by engines. sub prepare_path { my ($self, $ctx) = @_; - my $env = $self->env; + my $env = $ctx->request->env; my $scheme = $ctx->request->secure ? 'https' : 'http'; my $host = $env->{HTTP_HOST} || $env->{SERVER_NAME}; @@ -579,8 +587,9 @@ process the query string and extract query parameters. sub prepare_query_parameters { my ($self, $c) = @_; - my $query_string = exists $self->env->{QUERY_STRING} - ? $self->env->{QUERY_STRING} + my $env = $c->request->env; + my $query_string = exists $env->{QUERY_STRING} + ? $env->{QUERY_STRING} : ''; # Check for keywords (no = signs) @@ -630,11 +639,8 @@ prepare to read from the engine. sub prepare_read { my ( $self, $c ) = @_; - # Initialize the read position - $self->read_position(0); - # Initialize the amount of data we think we need to read - $self->read_length( $c->request->header('Content-Length') || 0 ); + $c->request->_read_length; } =head2 $self->prepare_request(@arguments) @@ -645,7 +651,9 @@ Populate the context object from the request object. sub prepare_request { my ($self, $ctx, %args) = @_; - $self->_set_env($args{env}); + $ctx->request->_set_env($args{env}); + $self->_set_env($args{env}); # Nasty back compat! + $ctx->response->_set_response_cb($args{response_cb}); } =head2 $self->prepare_uploads($c) @@ -694,14 +702,6 @@ sub prepare_uploads { } } -=head2 $self->prepare_write($c) - -Abstract method. Implemented by the engines. - -=cut - -sub prepare_write { } - =head2 $self->read($c, [$maxlength]) Reads from the input stream by calling C<< $self->read_chunk >>. @@ -713,12 +713,12 @@ Maintains the read_length and read_position counters as data is read. sub read { my ( $self, $c, $maxlength ) = @_; - my $remaining = $self->read_length - $self->read_position; + my $request = $c->request; + my $remaining = $request->_read_length - $request->_read_position; $maxlength ||= $CHUNKSIZE; # Are we done reading? if ( $remaining <= 0 ) { - $self->finalize_read($c); return; } @@ -727,10 +727,10 @@ sub read { if ( defined $rc ) { if (0 == $rc) { # Nothing more to read even though Content-Length # said there should be. - $self->finalize_read; return; } - $self->read_position( $self->read_position + $rc ); + my $request = $c->request; + $request->_read_position( $request->_read_position + $rc ); return $buffer; } else { @@ -739,7 +739,7 @@ sub read { } } -=head2 $self->read_chunk($c, $buffer, $length) +=head2 $self->read_chunk($c, \$buffer, $length) Each engine implements read_chunk as its preferred way of reading a chunk of data. Returns the number of bytes read. A return of 0 indicates that @@ -749,7 +749,7 @@ there is no more data to be read. sub read_chunk { my ($self, $ctx) = (shift, shift); - return $self->env->{'psgi.input'}->read(@_); + return $ctx->request->read_chunk(@_); } =head2 $self->read_length @@ -764,19 +764,38 @@ The amount of input data that has already been read. =head2 $self->run($app, $server) Start the engine. Builds a PSGI application and calls the -run method on the server passed in.. +run method on the server passed in, which then causes the +engine to loop, handling requests.. =cut sub run { - my ($self, $app, @args) = @_; - my $server = pop @args if blessed $args[-1]; - $server ||= Plack::Loader->auto(); # We're not being called from a script, - # so auto detect what backend to run on. - # This does *NOT* cover mod_perl. - # FIXME - Do something sensible with the options we're passed - my $psgi = $self->build_psgi_app($app, @args); - $server->run($psgi); + my ($self, $app, $psgi, @args) = @_; + # @args left here rather than just a $options, $server for back compat with the + # old style scripts which send a few args, then a hashref + + # They should never actually be used in the normal case as the Plack engine is + # passed in got all the 'standard' args via the loader in the script already. + + # FIXME - we should stash the options in an attribute so that custom args + # like Gitalist's --git_dir are possible to get from the app without stupid tricks. + my $server = pop @args if (scalar @args && blessed $args[-1]); + my $options = pop @args if (scalar @args && ref($args[-1]) eq 'HASH'); + # Back compat hack for applications with old (non Catalyst::Script) scripts to work in FCGI. + if (scalar @args && !ref($args[0])) { + if (my $listen = shift @args) { + $options->{listen} ||= [$listen]; + } + } + if (! $server ) { + $server = Catalyst::EngineLoader->new(application_name => ref($self))->auto(%$options); + # We're not being called from a script, so auto detect what backend to + # run on. This should never happen, as mod_perl never calls ->run, + # instead the $app->handle method is called per request. + $app->log->warn("Not supplied a Plack engine, falling back to engine auto-loader (are your scripts ancient?)") + } + $app->run_options($options); + $server->run($psgi, $options); } =head2 build_psgi_app ($app, @args) @@ -789,27 +808,14 @@ middleware if the using_frontend_proxy config setting is set. sub build_psgi_app { my ($self, $app, @args) = @_; - my $psgi_app = sub { + return sub { my ($env) = @_; return sub { my ($respond) = @_; - $self->_set_response_cb($respond); - $app->handle_request(env => $env); + $app->handle_request(env => $env, response_cb => $respond); }; }; - - $psgi_app = Plack::Middleware::Conditional->wrap( - $psgi_app, - condition => sub { - my ($env) = @_; - return if $app->config->{ignore_frontend_proxy}; - return $env->{REMOTE_ADDR} eq '127.0.0.1' || $app->config->{using_frontend_proxy}; - }, - builder => sub { Plack::Middleware::ReverseProxy->wrap($_[0]) }, - ); - - return $psgi_app; } =head2 $self->write($c, $buffer) @@ -821,15 +827,12 @@ Writes the buffer to the client. sub write { my ( $self, $c, $buffer ) = @_; - unless ( $self->_prepared_write ) { - $self->prepare_write($c); - $self->_prepared_write(1); - } + my $response = $c->response; - return 0 if !defined $buffer; + $buffer = q[] unless defined $buffer; my $len = length($buffer); - $self->_writer->write($buffer); + $c->res->_writer->write($buffer); return $len; } @@ -863,7 +866,7 @@ not directly available via Catalyst objects $c->request, $c->engine ... BEWARE: If you really need to access some environment variable from your Catalyst application you should use $c->engine->env->{VARNAME} instead of $ENV{VARNAME}, -as in some enviroments the %ENV hash does not contain what you would expect. +as in some environments the %ENV hash does not contain what you would expect. =head1 AUTHORS