X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Runtime.git;a=blobdiff_plain;f=lib%2FCatalyst%2FEngine.pm;h=407ceb5f9b8a37da23d0d43eafb0290ec86740d2;hp=e770f325fb97fd8ade0cbe9ecd6dbd4ec8af6260;hb=681086e7279935c38cae4b84264dc73b02b63df1;hpb=94edbd2cb9cb1f63d5e10bff36e4218c44d2e978 diff --git a/lib/Catalyst/Engine.pm b/lib/Catalyst/Engine.pm index e770f32..407ceb5 100644 --- a/lib/Catalyst/Engine.pm +++ b/lib/Catalyst/Engine.pm @@ -10,12 +10,17 @@ 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::Engine::Loader; use Encode (); use utf8; use namespace::clean -except => 'meta'; -has env => (is => 'rw'); +has env => (is => 'ro', writer => '_set_env', clearer => '_clear_env'); # input position and length has read_length => (is => 'rw'); @@ -23,6 +28,20 @@ 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; @@ -61,6 +80,12 @@ sub finalize_body { else { $self->write( $c, $body ); } + + $self->_writer->close; + $self->_clear_writer; + $self->_clear_env; + + return; } =head2 $self->finalize_cookies($c) @@ -305,7 +330,17 @@ Abstract method, allows engines to write headers to response =cut -sub finalize_headers { } +sub finalize_headers { + my ($self, $ctx) = @_; + + my @headers; + $ctx->response->headers->scan(sub { push @headers, @_ }); + + $self->_set_writer($self->_response_cb->([ $ctx->response->status, \@headers ])); + $self->_clear_response_cb; + + return; +} =head2 $self->finalize_read($c) @@ -404,7 +439,22 @@ Abstract method implemented in engines. =cut -sub prepare_connection { } +sub prepare_connection { + my ($self, $ctx) = @_; + + my $env = $self->env; + my $request = $ctx->request; + + $request->address( $env->{REMOTE_ADDR} ); + $request->hostname( $env->{REMOTE_HOST} ) + if exists $env->{REMOTE_HOST}; + $request->protocol( $env->{SERVER_PROTOCOL} ); + $request->remote_user( $env->{REMOTE_USER} ); + $request->method( $env->{REQUEST_METHOD} ); + $request->secure( $env->{'psgi.url_scheme'} eq 'https' ? 1 : 0 ); + + return; +} =head2 $self->prepare_cookies($c) @@ -424,7 +474,19 @@ sub prepare_cookies { =cut -sub prepare_headers { } +sub prepare_headers { + my ($self, $ctx) = @_; + + my $env = $self->env; + my $headers = $ctx->request->headers; + + for my $header (keys %{ $env }) { + next unless $header =~ /^(HTTP|CONTENT|COOKIE)/i; + (my $field = $header) =~ s/^HTTPS?_//; + $field =~ tr/_/-/; + $headers->header($field => $env->{$header}); + } +} =head2 $self->prepare_parameters($c) @@ -462,7 +524,61 @@ abstract method, implemented by engines. =cut -sub prepare_path { } +sub prepare_path { + my ($self, $ctx) = @_; + + my $env = $self->env; + + my $scheme = $ctx->request->secure ? 'https' : 'http'; + my $host = $env->{HTTP_HOST} || $env->{SERVER_NAME}; + my $port = $env->{SERVER_PORT} || 80; + my $base_path = $env->{SCRIPT_NAME} || "/"; + + # set the request URI + 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"; + + # HTTP_HOST will include the port even if it's 80/443 + $host =~ s/:(?:80|443)$//; + + if ($port !~ /^(?:80|443)$/ && $host !~ /:/) { + $host .= ":$port"; + } + + my $query = $env->{QUERY_STRING} ? '?' . $env->{QUERY_STRING} : ''; + my $uri = $scheme . '://' . $host . '/' . $path . $query; + + $ctx->request->uri( (bless \$uri, $uri_class)->canonical ); + + # set the base URI + # base must end in a slash + $base_path .= '/' unless $base_path =~ m{/$}; + + my $base_uri = $scheme . '://' . $host . $base_path; + + $ctx->request->base( bless \$base_uri, $uri_class ); + + return; +} =head2 $self->prepare_request($c) @@ -473,7 +589,11 @@ process the query string and extract query parameters. =cut sub prepare_query_parameters { - my ( $self, $c, $query_string ) = @_; + my ($self, $c) = @_; + + my $query_string = exists $self->env->{QUERY_STRING} + ? $self->env->{QUERY_STRING} + : ''; # Check for keywords (no = signs) # (yes, index() is faster than a regex :)) @@ -535,7 +655,10 @@ Populate the context object from the request object. =cut -sub prepare_request { } +sub prepare_request { + my ($self, $ctx, %args) = @_; + $self->_set_env($args{env}); +} =head2 $self->prepare_uploads($c) @@ -615,7 +738,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; } @@ -636,7 +759,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 @@ -647,13 +773,57 @@ header. The amount of input data that has already been read. -=head2 $self->run($c) +=head2 $self->run($app, $server) + +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, $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 blessed $args[-1]; + my $options = pop @args if ref($args[-1]) eq 'HASH'; + if (! $server ) { + $server = Catalyst::Engine::Loader->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) -Start the engine. Implemented by the various engine classes. +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 run { } +sub build_psgi_app { + my ($self, $app, @args) = @_; + + return sub { + my ($env) = @_; + + return sub { + my ($respond) = @_; + $self->_set_response_cb($respond); + $app->handle_request(env => $env); + }; + }; +} =head2 $self->write($c, $buffer) @@ -669,33 +839,12 @@ sub write { $self->_prepared_write(1); } - return 0 if !defined $buffer; - - my $len = length($buffer); - my $wrote = syswrite STDOUT, $buffer; - - if ( !defined $wrote && $! == EWOULDBLOCK ) { - # Unable to write on the first try, will retry in the loop below - $wrote = 0; - } - - if ( defined $wrote && $wrote < $len ) { - # We didn't write the whole buffer - while (1) { - my $ret = syswrite STDOUT, $buffer, $CHUNKSIZE, $wrote; - if ( defined $ret ) { - $wrote += $ret; - } - else { - next if $! == EWOULDBLOCK; - return; - } + $buffer = q[] unless defined $buffer; - last if $wrote >= $len; - } - } + my $len = length($buffer); + $self->_writer->write($buffer); - return $wrote; + return $len; } =head2 $self->unescape_uri($uri)