X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FEngine.pm;h=166a02d8c1031dd02ac801af730d14c589e01e26;hb=55f8e5163b1f5c502b92a9976350c611610c80e3;hp=f2bcba312e9deafa430aa2e6b69fef1d84e2c5e5;hpb=6ef62eb24297bfe15e444eaa2ba624fde4569e78;p=catagits%2FCatalyst-Runtime.git diff --git a/lib/Catalyst/Engine.pm b/lib/Catalyst/Engine.pm index f2bcba3..166a02d 100644 --- a/lib/Catalyst/Engine.pm +++ b/lib/Catalyst/Engine.pm @@ -1,40 +1,41 @@ package Catalyst::Engine; -use strict; -use base qw/Class::Data::Inheritable Class::Accessor::Fast/; -use attributes (); -use UNIVERSAL::require; -use CGI::Cookie; -use Data::Dumper; +use Moose; +with 'MooseX::Emulate::Class::Accessor::Fast'; + +use CGI::Simple::Cookie; +use Data::Dump qw/dump/; +use Errno 'EWOULDBLOCK'; use HTML::Entities; use HTTP::Headers; -use Time::HiRes qw/gettimeofday tv_interval/; -use Text::ASCIITable; -use Catalyst::Request; -use Catalyst::Request::Upload; -use Catalyst::Response; -use Catalyst::Utils; - -require Module::Pluggable::Fast; - -# For pretty dumps -$Data::Dumper::Terse = 1; - -__PACKAGE__->mk_classdata('components'); -__PACKAGE__->mk_accessors(qw/counter depth request response state/); - -*comp = \&component; -*req = \&request; -*res = \&response; - -# For backwards compatibility -*finalize_output = \&finalize_body; - -# For statistics -our $COUNT = 1; -our $START = time; -our $RECURSION = 1000; -our $DETACH = "catalyst_detach\n"; +use Plack::Loader; +use Catalyst::EngineLoader; +use Encode 2.21 'decode_utf8'; +use Plack::Request::Upload; +use Hash::MultiValue; +use namespace::clean -except => 'meta'; + +# 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; +}; + +# XXX - Only here for Engine::PSGI compat +sub prepare_connection { + my ($self, $ctx) = @_; + $ctx->request->prepare_connection; +} =head1 NAME @@ -48,260 +49,242 @@ See L. =head1 METHODS -=over 4 - -=item $c->benchmark($coderef) - -Takes a coderef with arguments and returns elapsed time as float. - - my ( $elapsed, $status ) = $c->benchmark( sub { return 1 } ); - $c->log->info( sprintf "Processing took %f seconds", $elapsed ); - -=cut - -sub benchmark { - my $c = shift; - my $code = shift; - my $time = [gettimeofday]; - my @return = &$code(@_); - my $elapsed = tv_interval $time; - return wantarray ? ( $elapsed, @return ) : $elapsed; -} - -=item $c->comp($name) - -=item $c->component($name) -Get a component object by name. +=head2 $self->finalize_body($c) - $c->comp('MyApp::Model::MyModel')->do_stuff; +Finalize body. Prints the response output as blocking stream if it looks like +a filehandle, otherwise write it out all in one go. If there is no body in +the response, we assume you are handling it 'manually', such as for nonblocking +style or asynchronous streaming responses. You do this by calling L +several times (which sends HTTP headers if needed) or you close over +C<< $response->write_fh >>. -Regex search for a component. - - $c->comp('mymodel')->do_stuff; +See L and L for more. =cut -sub component { - my $c = shift; - - if (@_) { - - my $name = shift; - - if ( my $component = $c->components->{$name} ) { - return $component; - } - - else { - for my $component ( keys %{ $c->components } ) { - return $c->components->{$component} if $component =~ /$name/i; +sub finalize_body { + my ( $self, $c ) = @_; + my $res = $c->response; # We use this all over + + ## If we've asked for the write 'filehandle' that means the application is + ## doing something custom and is expected to close the response + return if $res->_has_write_fh; + + my $body = $res->body; # save some typing + if($res->_has_response_cb) { + ## we have not called the response callback yet, so we are safe to send + ## the whole body to PSGI + + my @headers; + $res->headers->scan(sub { push @headers, @_ }); + + # We need to figure out what kind of body we have and normalize it to something + # PSGI can deal with + if(defined $body) { + # Handle objects first + if(blessed($body)) { + if($body->can('getline')) { + # Body is an IO handle that meets the PSGI spec. Nothing to normalize + } elsif($body->can('read')) { + + # In the past, Catalyst only looked for ->read not ->getline. It is very possible + # that one might have an object that respected read but did not have getline. + # As a result, we need to handle this case for backcompat. + + # We will just do the old loop for now. In a future version of Catalyst this support + # will be removed and one will have to rewrite their custom object or use + # Plack::Middleware::AdaptFilehandleRead. In anycase support for this is officially + # deprecated and described as such as of 5.90060 + + my $got; + do { + $got = read $body, my ($buffer), $CHUNKSIZE; + $got = 0 unless $self->write($c, $buffer ); + } while $got > 0; + + close $body; + return; + } else { + # Looks like for backcompat reasons we need to be able to deal + # with stringyfiable objects. + $body = ["$body"]; + } + } elsif(ref $body) { + if( (ref($body) eq 'GLOB') or (ref($body) eq 'ARRAY')) { + # Again, PSGI can just accept this, no transform needed. We don't officially + # document the body as arrayref at this time (and there's not specific test + # cases. we support it because it simplifies some plack compatibility logic + # and we might make it official at some point. + } else { + $c->log->error("${\ref($body)} is not a valid value for Response->body"); + return; + } + } else { + # Body is defined and not an object or reference. We assume a simple value + # and wrap it in an array for PSGI + $body = [$body]; } + } else { + # There's no body... + $body = []; } - } - - return sort keys %{ $c->components }; -} - -=item $c->counter - -Returns a hashref containing coderefs and execution counts. -(Needed for deep recursion detection) - -=item $c->depth - -Returns the actual forward depth. - -=item $c->error - -=item $c->error($error, ...) - -=item $c->error($arrayref) - -Returns an arrayref containing error messages. - - my @error = @{ $c->error }; - -Add a new error. - - $c->error('Something bad happened'); - -=cut - -sub error { - my $c = shift; - my $error = ref $_[0] eq 'ARRAY' ? $_[0] : [@_]; - push @{ $c->{error} }, @$error; - return $c->{error}; -} - -=item $c->execute($class, $coderef) - -Execute a coderef in given class and catch exceptions. -Errors are available via $c->error. - -=cut -sub execute { - my ( $c, $class, $code ) = @_; - $class = $c->components->{$class} || $class; - $c->state(0); - my $callsub = ( caller(1) )[3]; - - my $action = ''; - if ( $c->debug ) { - $action = $c->actions->{reverse}->{"$code"}; - $action = "/$action" unless $action =~ /\-\>/; - $c->counter->{"$code"}++; - - if ( $c->counter->{"$code"} > $RECURSION ) { - my $error = qq/Deep recursion detected in "$action"/; - $c->log->error($error); - $c->error($error); - $c->state(0); - return $c->state; + $res->_response_cb->([ $res->status, \@headers, $body]); + $res->_clear_response_cb; + + } else { + ## Now, if there's no response callback anymore, that means someone has + ## called ->write in order to stream 'some stuff along the way'. I think + ## for backcompat we still need to handle a ->body. I guess I could see + ## someone calling ->write to presend some stuff, and then doing the rest + ## via ->body, like in a template. + + ## We'll just use the old, existing code for this (or most of it) + + if(my $body = $res->body) { + + if ( blessed($body) && $body->can('read') or ref($body) eq 'GLOB' ) { + + ## In this case we have no choice and will fall back on the old + ## manual streaming stuff. Not optimal. This is deprecated as of 5.900560+ + + my $got; + do { + $got = read $body, my ($buffer), $CHUNKSIZE; + $got = 0 unless $self->write($c, $buffer ); + } while $got > 0; + + close $body; + } + else { + + # Case where body was set afgter calling ->write. We'd prefer not to + # support this, but I can see some use cases with the way most of the + # views work. + + $self->write($c, $body ); + } } - $action = "-> $action" if $callsub =~ /forward$/; + $res->_writer->close; + $res->_clear_writer; } - $c->{depth}++; - eval { - if ( $c->debug ) - { - my ( $elapsed, @state ) = - $c->benchmark( $code, $class, $c, @{ $c->req->args } ); - push @{ $c->{stats} }, [ $action, sprintf( '%fs', $elapsed ) ]; - $c->state(@state); - } - else { $c->state( &$code( $class, $c, @{ $c->req->args } ) || 0 ) } - }; - $c->{depth}--; - - if ( my $error = $@ ) { - - if ( $error eq $DETACH ) { die $DETACH if $c->{depth} > 1 } - else { - unless ( ref $error ) { - chomp $error; - $error = qq/Caught exception "$error"/; - } - - $c->log->error($error); - $c->error($error); - $c->state(0); - } - } - return $c->state; + return; } -=item $c->finalize +=head2 $self->finalize_cookies($c) -Finalize request. +Create CGI::Simple::Cookie objects from $c->res->cookies, and set them as +response headers. =cut -sub finalize { - my $c = shift; - - $c->finalize_cookies; - - if ( my $location = $c->response->redirect ) { - $c->log->debug(qq/Redirecting to "$location"/) if $c->debug; - $c->response->header( Location => $location ); - $c->response->status(302) if $c->response->status !~ /^3\d\d$/; - } - - if ( $#{ $c->error } >= 0 ) { - $c->finalize_error; - } - - if ( !$c->response->body && $c->response->status == 200 ) { - $c->finalize_error; - } - - if ( $c->response->body && !$c->response->content_length ) { - $c->response->content_length( bytes::length( $c->response->body ) ); - } +sub finalize_cookies { + my ( $self, $c ) = @_; + + my @cookies; + my $response = $c->response; + + foreach my $name (keys %{ $response->cookies }) { + + my $val = $response->cookies->{$name}; + + my $cookie = ( + blessed($val) + ? $val + : CGI::Simple::Cookie->new( + -name => $name, + -value => $val->{value}, + -expires => $val->{expires}, + -domain => $val->{domain}, + -path => $val->{path}, + -secure => $val->{secure} || 0, + -httponly => $val->{httponly} || 0, + ) + ); + if (!defined $cookie) { + $c->log->warn("undef passed in '$name' cookie value - not setting cookie") + if $c->debug; + next; + } - if ( $c->response->status =~ /^(1\d\d|[23]04)$/ ) { - $c->response->headers->remove_header("Content-Length"); - $c->response->body(''); + push @cookies, $cookie->as_string; } - if ( $c->request->method eq 'HEAD' ) { - $c->response->body(''); + for my $cookie (@cookies) { + $response->headers->push_header( 'Set-Cookie' => $cookie ); } - - my $status = $c->finalize_headers; - $c->finalize_body; - return $status; } -=item $c->finalize_output - -, see finalize_body - -=item $c->finalize_body - -Finalize body. - -=cut - -sub finalize_body { } - -=item $c->finalize_cookies +=head2 $self->finalize_error($c) -Finalize cookies. +Output an appropriate error message. Called if there's an error in $c +after the dispatch has finished. Will output debug messages if Catalyst +is in debug mode, or a `please come back later` message otherwise. =cut -sub finalize_cookies { - my $c = shift; - - while ( my ( $name, $cookie ) = each %{ $c->response->cookies } ) { - my $cookie = CGI::Cookie->new( - -name => $name, - -value => $cookie->{value}, - -expires => $cookie->{expires}, - -domain => $cookie->{domain}, - -path => $cookie->{path}, - -secure => $cookie->{secure} || 0 - ); - - $c->res->headers->push_header( 'Set-Cookie' => $cookie->as_string ); - } +sub _dump_error_page_element { + my ($self, $i, $element) = @_; + my ($name, $val) = @{ $element }; + + # This is fugly, but the metaclass is _HUGE_ and demands waaay too much + # scrolling. Suggestions for more pleasant ways to do this welcome. + local $val->{'__MOP__'} = "Stringified: " + . $val->{'__MOP__'} if ref $val eq 'HASH' && exists $val->{'__MOP__'}; + + my $text = encode_entities( dump( $val )); + sprintf <<"EOF", $name, $text; +

%s

+
+ 
%s
+
+EOF } -=item $c->finalize_error - -Finalize error. - -=cut - sub finalize_error { - my $c = shift; + my ( $self, $c ) = @_; + + $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. - $c->res->headers->content_type('text/html'); - my $name = $c->config->{name} || 'Catalyst Application'; + if ($c->can('encoding')) { + $c->{encoding} = ''; + } my ( $title, $error, $infos ); if ( $c->debug ) { - $error = join '
', @{ $c->error }; + + # For pretty dumps + $error = join '', map { + '

' + . encode_entities($_) + . '

' + } @{ $c->error }; $error ||= 'No output'; + $error = qq{
$error
}; $title = $name = "$name on Catalyst $Catalyst::VERSION"; - my $req = encode_entities Dumper $c->req; - my $res = encode_entities Dumper $c->res; - my $stash = encode_entities Dumper $c->stash; - $infos = <<""; -
-Request
-
$req
-Response
-
$res
-Stash
-
$stash
+ $name = "

$name

"; + + # Don't show context in the dump + $c->res->_clear_context; + # Don't show body parser in the dump + $c->req->_clear_body; + + my @infos; + my $i = 0; + for my $dump ( $c->dump_these ) { + push @infos, $self->_dump_error_page_element($i, $dump); + $i++; + } + $infos = join "\n", @infos; } else { $title = $name; @@ -309,59 +292,107 @@ sub finalize_error { $infos = <<""; 
 (en) Please come back later
+(fr) SVP veuillez revenir plus tard
 (de) Bitte versuchen sie es spaeter nocheinmal
-(nl) Gelieve te komen later terug
+(at) Konnten's bitt'schoen spaeter nochmal reinschauen
 (no) Vennligst prov igjen senere
-(fr) Veuillez revenir plus tard
-(es) Vuelto por favor mas adelante
-(pt) Voltado por favor mais tarde
-(it) Ritornato prego più successivamente
+(dk) Venligst prov igen senere
+(pl) Prosze sprobowac pozniej
+(pt) Por favor volte mais tarde
+(ru) Попробуйте еще раз позже
+(ua) Спробуйте ще раз пізніше
+(it) Per favore riprova più tardi
$name = ''; } $c->res->body( <<"" ); - + + + + $title + @@ -374,428 +405,449 @@ 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); } -=item $c->finalize_headers +=head2 $self->finalize_headers($c) -Finalize headers. +Allows engines to write headers to response =cut -sub finalize_headers { } +sub finalize_headers { + my ($self, $ctx) = @_; -=item $c->handler( $class, @arguments ) + $ctx->finalize_headers unless $ctx->response->finalized_headers; + return; +} -Handles the request. +=head2 $self->finalize_uploads($c) + +Clean up after uploads, deleting temp files. =cut -sub handler { - my ( $class, @arguments ) = @_; +sub finalize_uploads { + my ( $self, $c ) = @_; - # Always expect worst case! - my $status = -1; - eval { - my @stats = (); + # 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}; + unlink grep { -e $_ } map { $_->tempname } + (ref $upload eq 'ARRAY' ? @{$upload} : ($upload)); + } - my $handler = sub { - my $c = $class->prepare(@arguments); - $c->{stats} = \@stats; - $c->dispatch; - return $c->finalize; - }; +} - if ( $class->debug ) { - my $elapsed; - ( $elapsed, $status ) = $class->benchmark($handler); - $elapsed = sprintf '%f', $elapsed; - my $av = sprintf '%.3f', - ( $elapsed == 0 ? '??' : ( 1 / $elapsed ) ); - my $t = Text::ASCIITable->new; - $t->setCols( 'Action', 'Time' ); - $t->setColWidth( 'Action', 64, 1 ); - $t->setColWidth( 'Time', 9, 1 ); - - for my $stat (@stats) { $t->addRow( $stat->[0], $stat->[1] ) } - $class->log->info( "Request took $elapsed" . "s ($av/s)", - $t->draw ); - } - else { $status = &$handler } +=head2 $self->prepare_body($c) - }; +sets up the L object body using L - if ( my $error = $@ ) { - chomp $error; - $class->log->error(qq/Caught exception in engine "$error"/); - } +=cut + +sub prepare_body { + my ( $self, $c ) = @_; - $COUNT++; - return $status; + $c->request->prepare_body; } -=item $c->prepare(@arguments) +=head2 $self->prepare_body_chunk($c) -Turns the engine-specific request( Apache, CGI ... ) -into a Catalyst context . +Add a chunk to the request body. =cut -sub prepare { - my ( $class, @arguments ) = @_; - - my $c = bless { - counter => {}, - depth => 0, - request => Catalyst::Request->new( - { - arguments => [], - cookies => {}, - headers => HTTP::Headers->new, - parameters => {}, - secure => 0, - snippets => [], - uploads => {} - } - ), - response => Catalyst::Response->new( - { - body => '', - cookies => {}, - headers => HTTP::Headers->new( 'Content-Length' => 0 ), - status => 200 - } - ), - stash => {}, - state => 0 - }, $class; +# XXX - Can this be deleted? +sub prepare_body_chunk { + my ( $self, $c, $chunk ) = @_; - if ( $c->debug ) { - my $secs = time - $START || 1; - my $av = sprintf '%.3f', $COUNT / $secs; - $c->log->debug('**********************************'); - $c->log->debug("* Request $COUNT ($av/s) [$$]"); - $c->log->debug('**********************************'); - $c->res->headers->header( 'X-Catalyst' => $Catalyst::VERSION ); - } + $c->request->prepare_body_chunk($chunk); +} - $c->prepare_request(@arguments); - $c->prepare_connection; - $c->prepare_headers; - $c->prepare_cookies; - $c->prepare_path; - $c->prepare_action; +=head2 $self->prepare_body_parameters($c) - my $method = $c->req->method || ''; - my $path = $c->req->path || ''; - my $address = $c->req->address || ''; +Sets up parameters from body. - $c->log->debug(qq/"$method" request for "$path" from $address/) - if $c->debug; +=cut - if ( $c->request->method eq 'POST' and $c->request->content_length ) { +sub prepare_body_parameters { + my ( $self, $c ) = @_; - if ( $c->req->content_type eq 'application/x-www-form-urlencoded' ) { - $c->prepare_parameters; - } - elsif ( $c->req->content_type eq 'multipart/form-data' ) { - $c->prepare_parameters; - $c->prepare_uploads; - } - else { - $c->prepare_body; - } - } + $c->request->prepare_body_parameters; +} - if ( $c->request->method eq 'GET' ) { - $c->prepare_parameters; - } +=head2 $self->prepare_parameters($c) - if ( $c->debug && keys %{ $c->req->params } ) { - my $t = Text::ASCIITable->new; - $t->setCols( 'Key', 'Value' ); - $t->setColWidth( 'Key', 37, 1 ); - $t->setColWidth( 'Value', 36, 1 ); - for my $key ( sort keys %{ $c->req->params } ) { - my $param = $c->req->params->{$key}; - my $value = defined($param) ? $param : ''; - $t->addRow( $key, $value ); - } - $c->log->debug( 'Parameters are', $t->draw ); - } +Sets up parameters from query and post parameters. +If parameters have already been set up will clear +existing parameters and set up again. + +=cut - return $c; +sub prepare_parameters { + my ( $self, $c ) = @_; + + $c->request->_clear_parameters; + return $c->request->parameters; } -=item $c->prepare_action +=head2 $self->prepare_path($c) -Prepare action. +abstract method, implemented by engines. =cut -sub prepare_action { - my $c = shift; - my $path = $c->req->path; - my @path = split /\//, $c->req->path; - $c->req->args( \my @args ); - - while (@path) { - $path = join '/', @path; - if ( my $result = ${ $c->get_action($path) }[0] ) { - - # It's a regex - if ($#$result) { - my $match = $result->[1]; - my @snippets = @{ $result->[2] }; - $c->log->debug( - qq/Requested action is "$path" and matched "$match"/) - if $c->debug; - $c->log->debug( - 'Snippets are "' . join( ' ', @snippets ) . '"' ) - if ( $c->debug && @snippets ); - $c->req->action($match); - $c->req->snippets( \@snippets ); - } +sub prepare_path { + my ($self, $ctx) = @_; - else { - $c->req->action($path); - $c->log->debug(qq/Requested action is "$path"/) if $c->debug; - } + my $env = $ctx->request->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} || "/"; - $c->req->match($path); - last; + # 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$//; } - unshift @args, pop @path; + $path = $base_path . $path_info; + $path =~ s{^/+}{}; + $path =~ s/([^$URI::uric])/$URI::Escape::escapes{$1}/go; + $path =~ s/\?/%3F/g; # STUPID STUPID SPECIAL CASE } - - unless ( $c->req->action ) { - $c->req->action('default'); - $c->req->match(''); + else { + my $req_uri = $env->{REQUEST_URI}; + $req_uri =~ s/\?.*$//; + $path = $req_uri; + $path =~ s{^/+}{}; } - $c->log->debug( 'Arguments are "' . join( '/', @args ) . '"' ) - if ( $c->debug && @args ); -} + # 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)$//; -=item $c->prepare_body + if ($port !~ /^(?:80|443)$/ && $host !~ /:/) { + $host .= ":$port"; + } -Prepare message body. + my $query = $env->{QUERY_STRING} ? '?' . $env->{QUERY_STRING} : ''; + my $uri = $scheme . '://' . $host . '/' . $path . $query; -=cut + $ctx->request->uri( (bless \$uri, $uri_class)->canonical ); -sub prepare_body { } + # set the base URI + # base must end in a slash + $base_path .= '/' unless $base_path =~ m{/$}; -=item $c->prepare_connection + my $base_uri = $scheme . '://' . $host . $base_path; -Prepare connection. + $ctx->request->base( bless \$base_uri, $uri_class ); -=cut + return; +} -sub prepare_connection { } +=head2 $self->prepare_request($c) -=item $c->prepare_cookies +=head2 $self->prepare_query_parameters($c) -Prepare cookies. +process the query string and extract query parameters. =cut -sub prepare_cookies { - my $c = shift; +sub prepare_query_parameters { + my ($self, $c) = @_; + my $env = $c->request->env; - if ( my $header = $c->request->header('Cookie') ) { - $c->req->cookies( { CGI::Cookie->parse($header) } ); + if(my $query_obj = $env->{'plack.request.query'}) { + $c->request->query_parameters( + $c->request->_use_hash_multivalue ? + $query_obj->clone : + $query_obj->as_hashref_mixed); + return; } -} -=item $c->prepare_headers + my $query_string = exists $env->{QUERY_STRING} + ? $env->{QUERY_STRING} + : ''; + + # Check for keywords (no = signs) + # (yes, index() is faster than a regex :)) + if ( index( $query_string, '=' ) < 0 ) { + my $keywords = $self->unescape_uri($query_string); + $keywords = decode_utf8 $keywords; + $c->request->query_keywords($keywords); + return; + } -Prepare headers. + my %query; -=cut + # replace semi-colons + $query_string =~ s/;/&/g; -sub prepare_headers { } + my @params = grep { length $_ } split /&/, $query_string; -=item $c->prepare_parameters + for my $item ( @params ) { -Prepare parameters. + my ($param, $value) + = map { decode_utf8($self->unescape_uri($_)) } + split( /=/, $item, 2 ); -=cut + unless(defined $param) { + $param = $self->unescape_uri($item); + $param = decode_utf8 $param; + } -sub prepare_parameters { } + if ( exists $query{$param} ) { + if ( ref $query{$param} ) { + push @{ $query{$param} }, $value; + } + else { + $query{$param} = [ $query{$param}, $value ]; + } + } + else { + $query{$param} = $value; + } + } -=item $c->prepare_path + $c->request->query_parameters( + $c->request->_use_hash_multivalue ? + Hash::MultiValue->from_mixed(\%query) : + \%query); +} -Prepare path and base. +=head2 $self->prepare_read($c) + +Prepare to read by initializing the Content-Length from headers. =cut -sub prepare_path { } +sub prepare_read { + my ( $self, $c ) = @_; -=item $c->prepare_request + # Initialize the amount of data we think we need to read + $c->request->_read_length; +} -Prepare the engine request. +=head2 $self->prepare_request(@arguments) -=cut +Populate the context object from the request object. -sub prepare_request { } +=cut -=item $c->prepare_uploads +sub prepare_request { + my ($self, $ctx, %args) = @_; + $ctx->log->psgienv($args{env}) if $ctx->log->can('psgienv'); + $ctx->request->_set_env($args{env}); + $self->_set_env($args{env}); # Nasty back compat! + $ctx->response->_set_response_cb($args{response_cb}); +} -Prepare uploads. +=head2 $self->prepare_uploads($c) =cut -sub prepare_uploads { } +sub prepare_uploads { + my ( $self, $c ) = @_; + + my $request = $c->request; + return unless $request->_body; + + my $enc = $c->encoding; + my $uploads = $request->_body->upload; + my $parameters = $request->parameters; + foreach my $name (keys %$uploads) { + $name = $c->_handle_unicode_decoding($name) if $enc; + my $files = $uploads->{$name}; + my @uploads; + for my $upload (ref $files eq 'ARRAY' ? @$files : ($files)) { + my $headers = HTTP::Headers->new( %{ $upload->{headers} } ); + my $filename = $upload->{filename}; + $filename = $c->_handle_unicode_decoding($filename) if $enc; + + my $u = Catalyst::Request::Upload->new + ( + size => $upload->{size}, + type => scalar $headers->content_type, + headers => $headers, + tempname => $upload->{tempname}, + filename => $filename, + ); + push @uploads, $u; + } + $request->uploads->{$name} = @uploads > 1 ? \@uploads : $uploads[0]; + + # support access to the filename as a normal param + my @filenames = map { $_->{filename} } @uploads; + # append, if there's already params with this name + if (exists $parameters->{$name}) { + if (ref $parameters->{$name} eq 'ARRAY') { + push @{ $parameters->{$name} }, @filenames; + } + else { + $parameters->{$name} = [ $parameters->{$name}, @filenames ]; + } + } + else { + $parameters->{$name} = @filenames > 1 ? \@filenames : $filenames[0]; + } + } +} -=item $c->run +=head2 $self->write($c, $buffer) -Starts the engine. +Writes the buffer to the client. =cut -sub run { } - -=item $c->request - -=item $c->req +sub write { + my ( $self, $c, $buffer ) = @_; -Returns a C object. + $c->response->write($buffer); +} - my $req = $c->req; +=head2 $self->read($c, [$maxlength]) -=item $c->response +Reads from the input stream by calling C<< $self->read_chunk >>. -=item $c->res +Maintains the read_length and read_position counters as data is read. -Returns a C object. +=cut - my $res = $c->res; +sub read { + my ( $self, $c, $maxlength ) = @_; -=item $class->setup + $c->request->read($maxlength); +} -Setup. +=head2 $self->read_chunk($c, \$buffer, $length) - MyApp->setup; +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 +there is no more data to be read. =cut -sub setup { - my $self = shift; - - # Initialize our data structure - $self->components( {} ); +sub read_chunk { + my ($self, $ctx) = (shift, shift); + return $ctx->request->read_chunk(@_); +} - $self->setup_components; +=head2 $self->run($app, $server) - if ( $self->debug ) { - my $t = Text::ASCIITable->new; - $t->setOptions( 'hide_HeadRow', 1 ); - $t->setOptions( 'hide_HeadLine', 1 ); - $t->setCols('Class'); - $t->setColWidth( 'Class', 75, 1 ); - $t->addRow($_) for sort keys %{ $self->components }; - $self->log->debug( 'Loaded components', $t->draw ) - if ( @{ $t->{tbl_rows} } ); - } +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.. - # Add our self to components, since we are also a component - $self->components->{$self} = $self; - - $self->setup_actions; +=cut - if ( $self->debug ) { - my $name = $self->config->{name} || 'Application'; - $self->log->info("$name powered by Catalyst $Catalyst::VERSION"); +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 (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); } -=item $class->setup_components +=head2 build_psgi_app ($app, @args) -Setup components. +Builds and returns a PSGI application closure. (Raw, not wrapped in middleware) =cut -sub setup_components { - my $self = shift; +sub build_psgi_app { + my ($self, $app, @args) = @_; - my $callback = sub { - my ( $component, $context ) = @_; + return sub { + my ($env) = @_; - unless ( $component->isa('Catalyst::Base') ) { - return $component; - } + return sub { + my ($respond) = @_; + confess("Did not get a response callback for writer, cannot continue") unless $respond; + $app->handle_request(env => $env, response_cb => $respond); + }; + }; +} - my $suffix = Catalyst::Utils::class2classsuffix($component); - my $config = $self->config->{$suffix} || {}; +=head2 $self->unescape_uri($uri) - my $instance; +Unescapes a given URI using the most efficient method available. Engines such +as Apache may implement this using Apache's C-based modules, for example. - eval { $instance = $component->new( $context, $config ); }; +=cut - if ( my $error = $@ ) { - chomp $error; - die qq/Couldn't instantiate component "$component", "$error"/; - } +sub unescape_uri { + my ( $self, $str ) = @_; - return $instance; - }; + $str =~ s/(?:%([0-9A-Fa-f]{2})|\+)/defined $1 ? chr(hex($1)) : ' '/eg; - eval { - Module::Pluggable::Fast->import( - name => '_components', - search => [ - "$self\::Controller", "$self\::C", - "$self\::Model", "$self\::M", - "$self\::View", "$self\::V" - ], - callback => $callback - ); - }; - - if ( my $error = $@ ) { - chomp $error; - die qq/Couldn't load components "$error"/; - } - - for my $component ( $self->_components($self) ) { - $self->components->{ ref $component || $component } = $component; - } + return $str; } -=item $c->state - -Contains the return value of the last executed action. - -=item $c->stash +=head2 $self->finalize_output -Returns a hashref containing all your data. +, see finalize_body - $c->stash->{foo} ||= 'yada'; - print $c->stash->{foo}; +=head2 $self->env -=cut +Hash containing environment variables including many special variables inserted +by WWW server - like SERVER_*, REMOTE_*, HTTP_* ... -sub stash { - my $self = shift; - if (@_) { - my $stash = @_ > 1 ? {@_} : $_[0]; - while ( my ( $key, $val ) = each %$stash ) { - $self->{stash}->{$key} = $val; - } - } - return $self->{stash}; -} +Before accessing environment variables consider whether the same information is +not directly available via Catalyst objects $c->request, $c->engine ... -=back +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 environments the %ENV hash does not contain what you would expect. -=head1 AUTHOR +=head1 AUTHORS -Sebastian Riedel, C +Catalyst Contributors, see Catalyst.pm =head1 COPYRIGHT -This program is free software, you can redistribute it and/or modify it under +This library is free software. You can redistribute it and/or modify it under the same terms as Perl itself. =cut +__PACKAGE__->meta->make_immutable; + 1;