X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FEngine.pm;h=23df09316ece1429a00ded34929c405c55f968c6;hb=ad79be3450d4ece7161e721bc65debdb98e677f5;hp=b802f6ceabcdcd9c8bde8ec48b3d42a4ad69da24;hpb=030674d07b88cee2269524f79edb8841e2470202;p=catagits%2FCatalyst-Runtime.git diff --git a/lib/Catalyst/Engine.pm b/lib/Catalyst/Engine.pm index b802f6c..23df093 100644 --- a/lib/Catalyst/Engine.pm +++ b/lib/Catalyst/Engine.pm @@ -11,6 +11,10 @@ use HTTP::Body; use HTTP::Headers; use URI::QueryParam; use Moose::Util::TypeConstraints; +use Plack::Loader; +use Catalyst::EngineLoader; +use Encode (); +use utf8; use namespace::clean -except => 'meta'; @@ -23,15 +27,17 @@ has read_position => (is => 'rw'); has _prepared_write => (is => 'rw'); has _response_cb => ( - is => 'ro', - isa => 'CodeRef', - writer => '_set_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', + is => 'ro', + isa => duck_type([qw(write close)]), + writer => '_set_writer', + clearer => '_clear_writer', ); # Amount of data to read from input on each pass @@ -74,7 +80,7 @@ sub finalize_body { } $self->_writer->close; - + $self->_clear_writer; $self->_clear_env; return; @@ -150,6 +156,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 ) { @@ -298,10 +312,12 @@ sub finalize_error { - - # Trick IE + # 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); } @@ -319,6 +335,7 @@ sub finalize_headers { $ctx->response->headers->scan(sub { push @headers, @_ }); $self->_set_writer($self->_response_cb->([ $ctx->response->status, \@headers ])); + $self->_clear_response_cb; return; } @@ -338,6 +355,8 @@ Clean up after uploads, deleting temp files. sub finalize_uploads { my ( $self, $c ) = @_; + # N.B. This code is theoretically entirely unneeded due to ->cleanup(1) + # on the HTTP::Body object. my $request = $c->request; foreach my $key (keys %{ $request->uploads }) { my $upload = $request->uploads->{$key}; @@ -362,6 +381,7 @@ sub prepare_body { unless ( $request->_body ) { my $type = $request->header('Content-Type'); $request->_body(HTTP::Body->new( $type, $length )); + $request->_body->cleanup(1); # Make extra sure! $request->_body->tmpdir( $appclass->config->{uploadtmp} ) if exists $appclass->config->{uploadtmp}; } @@ -429,7 +449,7 @@ sub prepare_connection { $request->protocol( $env->{SERVER_PROTOCOL} ); $request->remote_user( $env->{REMOTE_USER} ); $request->method( $env->{REQUEST_METHOD} ); - $request->secure( $env->{'psgi.url_scheme'} eq 'https' ); + $request->secure( $env->{'psgi.url_scheme'} eq 'https' ? 1 : 0 ); return; } @@ -513,10 +533,24 @@ sub prepare_path { my $base_path = $env->{SCRIPT_NAME} || "/"; # set the request URI - my $req_uri = $env->{REQUEST_URI}; - $req_uri =~ s/\?.*$//; - my $path = $self->unescape_uri($req_uri); - $path =~ s{^/+}{}; + my $path; + if (!$ctx->config->{use_request_uri_for_path}) { + my $path_info = $env->{PATH_INFO}; + if ( exists $env->{REDIRECT_URL} ) { + $base_path = $env->{REDIRECT_URL}; + $base_path =~ s/\Q$path_info\E$//; + } + $path = $base_path . $path_info; + $path =~ s{^/+}{}; + $path =~ s/([^$URI::uric])/$URI::Escape::escapes{$1}/go; + $path =~ s/\?/%3F/g; # STUPID STUPID SPECIAL CASE + } + else { + my $req_uri = $env->{REQUEST_URI}; + $req_uri =~ s/\?.*$//; + $path = $req_uri; + $path =~ s{^/+}{}; + } # Using URI directly is way too slow, so we construct the URLs manually my $uri_class = "URI::$scheme"; @@ -528,14 +562,10 @@ sub prepare_path { $host .= ":$port"; } - # Escape the path - $path =~ s/([^$URI::uric])/$URI::Escape::escapes{$1}/go; - $path =~ s/\?/%3F/g; # STUPID STUPID SPECIAL CASE - my $query = $env->{QUERY_STRING} ? '?' . $env->{QUERY_STRING} : ''; my $uri = $scheme . '://' . $host . '/' . $path . $query; - $ctx->request->uri( bless \$uri, $uri_class ); + $ctx->request->uri( (bless \$uri, $uri_class)->canonical ); # set the base URI # base must end in a slash @@ -648,7 +678,7 @@ sub prepare_uploads { my $u = Catalyst::Request::Upload->new ( size => $upload->{size}, - type => $headers->content_type, + type => scalar $headers->content_type, headers => $headers, tempname => $upload->{tempname}, filename => $upload->{filename}, @@ -706,7 +736,7 @@ sub read { my $rc = $self->read_chunk( $c, my $buffer, $readlen ); if ( defined $rc ) { if (0 == $rc) { # Nothing more to read even though Content-Length - # said there should be. FIXME - Warn in the log here? + # said there should be. $self->finalize_read; return; } @@ -727,7 +757,10 @@ there is no more data to be read. =cut -sub read_chunk { } +sub read_chunk { + my ($self, $ctx) = (shift, shift); + return $self->env->{'psgi.input'}->read(@_); +} =head2 $self->read_length @@ -738,14 +771,47 @@ header. The amount of input data that has already been read. -=head2 $self->run($c) +=head2 $self->run($app, $server) -Start the engine. Implemented by the various engine classes. +Start the engine. Builds a PSGI application and calls the +run method on the server passed in, which then causes the +engine to loop, handling requests.. =cut sub run { - my ($self, $app) = @_; + 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'); + if (! $server ) { + $server = Catalyst::EngineLoader->new(application_name => ref($self))->auto(); + # 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?)") + } + $server->run($psgi, $options); +} + +=head2 build_psgi_app ($app, @args) + +Builds and returns a PSGI application closure, wrapping it in the reverse proxy +middleware if the using_frontend_proxy config setting is set. + +=cut + +sub build_psgi_app { + my ($self, $app, @args) = @_; return sub { my ($env) = @_; @@ -772,7 +838,7 @@ sub write { $self->_prepared_write(1); } - return 0 if !defined $buffer; + $buffer = q[] unless defined $buffer; my $len = length($buffer); $self->_writer->write($buffer); @@ -801,13 +867,13 @@ sub unescape_uri { =head2 $self->env -Hash containing enviroment variables including many special variables inserted +Hash containing environment variables including many special variables inserted by WWW server - like SERVER_*, REMOTE_*, HTTP_* ... -Before accesing enviroment variables consider whether the same information is +Before accessing environment variables consider whether the same information is not directly available via Catalyst objects $c->request, $c->engine ... -BEWARE: If you really need to access some enviroment variable from your Catalyst +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.