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=0389367c3092713fb1e284965051452d3618ead4;hp=3e7cfbda39c153034a8bf18b9229cfb72398ac7e;hb=f3414019f472b55682ef3af53f761b6db7955887;hpb=a268a0112398ac10d8fabd86ed28a183cbe4398e diff --git a/lib/Catalyst/Engine.pm b/lib/Catalyst/Engine.pm index 3e7cfbd..0389367 100644 --- a/lib/Catalyst/Engine.pm +++ b/lib/Catalyst/Engine.pm @@ -1,39 +1,26 @@ 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 Class::C3; +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::Body; 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 request response state/); +use URI::QueryParam; +use Scalar::Util (); -*comp = \&component; -*req = \&request; -*res = \&response; +# input position and length +has read_length => (is => 'rw'); +has read_position => (is => 'rw'); -# For backwards compatibility -*finalize_output = \&finalize_body; +no Moose; -# For statistics -our $COUNT = 1; -our $START = time; -our $RECURSION = 1000; +# Amount of data to read from input on each pass +our $CHUNKSIZE = 64 * 1024; =head1 NAME @@ -47,242 +34,116 @@ 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. - - $c->comp('MyApp::Model::MyModel')->do_stuff; - -Regex search for a component. - - $c->comp('mymodel')->do_stuff; - -=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; - } - } - } - - return sort keys %{ $c->components }; -} - -=item $c->counter - -Returns a hashref containing coderefs and execution counts. -(Needed for deep recursion detection) - -=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'); +=head2 $self->finalize_body($c) -=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. +Finalize body. Prints the response output. =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; +sub finalize_body { + my ( $self, $c ) = @_; + my $body = $c->response->body; + no warnings 'uninitialized'; + if ( Scalar::Util::blessed($body) && $body->can('read') or ref($body) eq 'GLOB' ) { + while ( !eof $body ) { + read $body, my ($buffer), $CHUNKSIZE; + last unless $self->write( $c, $buffer ); } - - $action = "-> $action" if $callsub =~ /forward$/; + close $body; } - - 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 ) } - }; - - if ( my $error = $@ ) { - - unless ( ref $error ) { - chomp $error; - $error = qq/Caught exception "$error"/; - } - - $c->log->error($error); - $c->error($error); - $c->state(0); - } - return $c->state; -} - -=item $c->finalize - -Finalize request. - -=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 !~ /^(1|3)\d\d$/ ) { - $c->finalize_error; - } - - if ( $c->response->body && !$c->response->content_length ) { - use bytes; # play safe with a utf8 aware perl - $c->response->content_length( length $c->response->body ); + else { + $self->write( $c, $body ); } - - 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_cookies($c) -Finalize cookies. +Create CGI::Simple::Cookie objects from $c->res->cookies, and set them as +response headers. =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 + my ( $self, $c ) = @_; + + my @cookies; + my $response = $c->response; + + foreach my $name (keys %{ $response->cookies }) { + + my $val = $response->cookies->{$name}; + + my $cookie = ( + Scalar::Util::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 + ) ); - $c->res->headers->push_header( 'Set-Cookie' => $cookie->as_string ); + push @cookies, $cookie->as_string; + } + + for my $cookie (@cookies) { + $response->headers->push_header( 'Set-Cookie' => $cookie ); } } -=item $c->finalize_error +=head2 $self->finalize_error($c) -Finalize error. +Output an apropriate 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_error { - my $c = shift; + my ( $self, $c ) = @_; - $c->res->headers->content_type('text/html'); - my $name = $c->config->{name} || 'Catalyst Application'; + $c->res->content_type('text/html; charset=utf-8'); + my $name = $c->config->{name} || join(' ', split('::', ref $c)); 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 + delete $c->req->{_context}; + delete $c->res->{_context}; + + # Don't show body parser in the dump + delete $c->req->{_body}; + + my @infos; + my $i = 0; + for my $dump ( $c->dump_these ) { + my $name = $dump->[0]; + my $value = encode_entities( dump( $dump->[1] )); + push @infos, sprintf <<"EOF", $name, $value; +

%s

+
+ 
%s
+
+EOF + $i++; + } + $infos = join "\n", @infos; } else { $title = $name; @@ -290,59 +151,103 @@ 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
$name = ''; } $c->res->body( <<"" ); - + + + + $title + @@ -355,422 +260,420 @@ sub finalize_error { + + # Trick IE + $c->res->{body} .= ( ' ' x 512 ); + + # Return 500 + $c->res->status(500); } -=item $c->finalize_headers +=head2 $self->finalize_headers($c) -Finalize headers. +Abstract method, allows engines to write headers to response =cut sub finalize_headers { } -=item $c->handler( $class, @arguments ) - -Handles the request. +=head2 $self->finalize_read($c) =cut -sub handler { - my ( $class, @arguments ) = @_; - - # Always expect worst case! - my $status = -1; - eval { - my @stats = (); - - 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 } - - }; - - if ( my $error = $@ ) { - chomp $error; - $class->log->error(qq/Caught exception in engine "$error"/); - } - - $COUNT++; - return $status; -} +sub finalize_read { } -=item $c->prepare(@arguments) +=head2 $self->finalize_uploads($c) -Turns the engine-specific request( Apache, CGI ... ) -into a Catalyst context . +Clean up after uploads, deleting temp files. =cut -sub prepare { - my ( $class, @arguments ) = @_; - - my $c = bless { - counter => {}, - 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, - status => 200 - } - ), - stash => {}, - state => 0 - }, $class; +sub finalize_uploads { + my ( $self, $c ) = @_; - 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 ); + 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)); } - $c->prepare_request(@arguments); - $c->prepare_connection; - $c->prepare_headers; - $c->prepare_cookies; - $c->prepare_path; - $c->prepare_action; +} - my $method = $c->req->method || ''; - my $path = $c->req->path || ''; - my $address = $c->req->address || ''; +=head2 $self->prepare_body($c) - $c->log->debug(qq/"$method" request for "$path" from $address/) - if $c->debug; +sets up the L object body using L - if ( $c->request->method eq 'POST' and $c->request->content_length ) { +=cut - 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; +sub prepare_body { + my ( $self, $c ) = @_; + + if ( my $length = $self->read_length ) { + my $request = $c->request; + unless ( $request->{_body} ) { + my $type = $request->header('Content-Type'); + $request->{_body} = HTTP::Body->new( $type, $length ); + $request->{_body}->{tmpdir} = $c->config->{uploadtmp} + if exists $c->config->{uploadtmp}; } - else { - $c->prepare_body; + + while ( my $buffer = $self->read($c) ) { + $c->prepare_body_chunk($buffer); } - } - - if ( $c->request->method eq 'GET' ) { - $c->prepare_parameters; - } - 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 ); + # paranoia against wrong Content-Length header + my $remaining = $length - $self->read_position; + if ( $remaining > 0 ) { + $self->finalize_read($c); + Catalyst::Exception->throw( + "Wrong Content-Length value: $length" ); } - $c->log->debug( 'Parameters are', $t->draw ); } - - return $c; + else { + # Defined but will cause all body code to be skipped + $c->request->{_body} = 0; + } } -=item $c->prepare_action +=head2 $self->prepare_body_chunk($c) -Prepare action. +Add a chunk to the request body. =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 ); - } - - else { - $c->req->action($path); - $c->log->debug(qq/Requested action is "$path"/) if $c->debug; - } +sub prepare_body_chunk { + my ( $self, $c, $chunk ) = @_; - $c->req->match($path); - last; - } - unshift @args, pop @path; - } - - unless ( $c->req->action ) { - $c->req->action('default'); - $c->req->match(''); - } - - $c->log->debug( 'Arguments are "' . join( '/', @args ) . '"' ) - if ( $c->debug && @args ); + $c->request->{_body}->add($chunk); } -=item $c->prepare_body +=head2 $self->prepare_body_parameters($c) -Prepare message body. +Sets up parameters from body. =cut -sub prepare_body { } +sub prepare_body_parameters { + my ( $self, $c ) = @_; + + return unless $c->request->{_body}; + + $c->request->body_parameters( $c->request->{_body}->param ); +} -=item $c->prepare_connection +=head2 $self->prepare_connection($c) -Prepare connection. +Abstract method implemented in engines. =cut sub prepare_connection { } -=item $c->prepare_cookies +=head2 $self->prepare_cookies($c) -Prepare cookies. +Parse cookies from header. Sets a L object. =cut sub prepare_cookies { - my $c = shift; + my ( $self, $c ) = @_; if ( my $header = $c->request->header('Cookie') ) { - $c->req->cookies( { CGI::Cookie->parse($header) } ); + $c->req->cookies( { CGI::Simple::Cookie->parse($header) } ); } } -=item $c->prepare_headers - -Prepare headers. +=head2 $self->prepare_headers($c) =cut sub prepare_headers { } -=item $c->prepare_parameters +=head2 $self->prepare_parameters($c) -Prepare parameters. +sets up parameters from query and post parameters. =cut -sub prepare_parameters { } +sub prepare_parameters { + my ( $self, $c ) = @_; + + my $request = $c->request; + my $parameters = $request->parameters; + my $body_parameters = $request->body_parameters; + my $query_parameters = $request->query_parameters; + # We copy, no references + foreach my $name (keys %$query_parameters) { + my $param = $query_parameters->{$name}; + $parameters->{$name} = ref $param eq 'ARRAY' ? [ @$param ] : $param; + } -=item $c->prepare_path + # Merge query and body parameters + foreach my $name (keys %$body_parameters) { + my $param = $body_parameters->{$name}; + my @values = ref $param eq 'ARRAY' ? @$param : ($param); + if ( my $existing = $parameters->{$name} ) { + unshift(@values, (ref $existing eq 'ARRAY' ? @$existing : $existing)); + } + $parameters->{$name} = @values > 1 ? \@values : $values[0]; + } +} -Prepare path and base. +=head2 $self->prepare_path($c) + +abstract method, implemented by engines. =cut sub prepare_path { } -=item $c->prepare_request +=head2 $self->prepare_request($c) -Prepare the engine request. +=head2 $self->prepare_query_parameters($c) -=cut +process the query string and extract query parameters. -sub prepare_request { } +=cut -=item $c->prepare_uploads +sub prepare_query_parameters { + my ( $self, $c, $query_string ) = @_; + + # Check for keywords (no = signs) + # (yes, index() is faster than a regex :)) + if ( index( $query_string, '=' ) < 0 ) { + $c->request->query_keywords( $self->unescape_uri($query_string) ); + return; + } -Prepare uploads. + my %query; -=cut + # replace semi-colons + $query_string =~ s/;/&/g; + + my @params = split /&/, $query_string; + + for my $item ( @params ) { + + my ($param, $value) + = map { $self->unescape_uri($_) } + split( /=/, $item, 2 ); + + $param = $self->unescape_uri($item) unless defined $param; + + if ( exists $query{$param} ) { + if ( ref $query{$param} ) { + push @{ $query{$param} }, $value; + } + else { + $query{$param} = [ $query{$param}, $value ]; + } + } + else { + $query{$param} = $value; + } + } -sub prepare_uploads { } + $c->request->query_parameters( \%query ); +} -=item $c->run +=head2 $self->prepare_read($c) -Starts the engine. +prepare to read from the engine. =cut -sub run { } - -=item $c->request +sub prepare_read { + my ( $self, $c ) = @_; -=item $c->req + # 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 ); +} -Returns a C object. +=head2 $self->prepare_request(@arguments) - my $req = $c->req; +Populate the context object from the request object. -=item $c->response +=cut -=item $c->res +sub prepare_request { } -Returns a C object. +=head2 $self->prepare_uploads($c) - my $res = $c->res; +=cut -=item $class->setup +sub prepare_uploads { + my ( $self, $c ) = @_; + + my $request = $c->request; + return unless $request->{_body}; + + my $uploads = $request->{_body}->upload; + my $parameters = $request->parameters; + foreach my $name (keys %$uploads) { + my $files = $uploads->{$name}; + my @uploads; + for my $upload (ref $files eq 'ARRAY' ? @$files : ($files)) { + my $headers = HTTP::Headers->new( %{ $upload->{headers} } ); + my $u = Catalyst::Request::Upload->new + ( + size => $upload->{size}, + type => $headers->content_type, + headers => $headers, + tempname => $upload->{tempname}, + filename => $upload->{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]; + } + } +} -Setup. +=head2 $self->prepare_write($c) - MyApp->setup; +Abstract method. Implemented by the engines. =cut -sub setup { - my $self = shift; +sub prepare_write { } - # Initialize our data structure - $self->components( {} ); +=head2 $self->read($c, [$maxlength]) - $self->setup_components; +=cut - 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} } ); - } - - # Add our self to components, since we are also a component - $self->components->{ $self } = $self; +sub read { + my ( $self, $c, $maxlength ) = @_; - $self->setup_actions; + my $remaining = $self->read_length - $self->read_position; + $maxlength ||= $CHUNKSIZE; - if ( $self->debug ) { - my $name = $self->config->{name} || 'Application'; - $self->log->info("$name powered by Catalyst $Catalyst::VERSION"); + # Are we done reading? + if ( $remaining <= 0 ) { + $self->finalize_read($c); + return; + } + + my $readlen = ( $remaining > $maxlength ) ? $maxlength : $remaining; + my $rc = $self->read_chunk( $c, my $buffer, $readlen ); + if ( defined $rc ) { + $self->read_position( $self->read_position + $rc ); + return $buffer; + } + else { + Catalyst::Exception->throw( + message => "Unknown error reading input: $!" ); } } -=item $class->setup_components +=head2 $self->read_chunk($c, $buffer, $length) -Setup components. +Each engine inplements read_chunk as its preferred way of reading a chunk +of data. =cut -sub setup_components { - my $self = shift; - - my $callback = sub { - my ( $component, $context ) = @_; +sub read_chunk { } - unless ( $component->isa('Catalyst::Base') ) { - return $component; - } +=head2 $self->read_length - my $suffix = Catalyst::Utils::class2classsuffix($component); - my $config = $self->config->{$suffix} || {}; +The length of input data to be read. This is obtained from the Content-Length +header. - my $instance; +=head2 $self->read_position - eval { - $instance = $component->new( $context, $config ); - }; +The amount of input data that has already been read. - if ( $@ ) { - die qq/Couldn't instantiate component "$component", "$@"/; - } +=head2 $self->run($c) - return $instance; - }; - - eval { - Module::Pluggable::Fast->import( - name => '_components', - search => [ - "$self\::Controller", "$self\::C", - "$self\::Model", "$self\::M", - "$self\::View", "$self\::V" - ], - callback => $callback - ); - }; +Start the engine. Implemented by the various engine classes. - if ( my $error = $@ ) { - chomp $error; - die qq/Couldn't load components "$error"/; - } +=cut - for my $component ( $self->_components($self) ) { - $self->components->{ ref $component || $component } = $component; - } -} +sub run { } -=item $c->state +=head2 $self->write($c, $buffer) -Contains the return value of the last executed action. +Writes the buffer to the client. -=item $c->stash +=cut -Returns a hashref containing all your data. +sub write { + my ( $self, $c, $buffer ) = @_; - $c->stash->{foo} ||= 'yada'; - print $c->stash->{foo}; + unless ( $self->{_prepared_write} ) { + $self->prepare_write($c); + $self->{_prepared_write} = 1; + } + + 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; + } + + last if $wrote >= $len; + } + } + + return $wrote; +} + +=head2 $self->unescape_uri($uri) + +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. =cut -sub stash { - my $self = shift; - if (@_) { - my $stash = @_ > 1 ? {@_} : $_[0]; - while ( my ( $key, $val ) = each %$stash ) { - $self->{stash}->{$key} = $val; - } - } - return $self->{stash}; +sub unescape_uri { + my ( $self, $str ) = @_; + + $str =~ s/(?:%([0-9A-Fa-f]{2})|\+)/defined $1 ? chr(hex($1)) : ' '/eg; + + return $str; } -=back +=head2 $self->finalize_output + +, see finalize_body + +=head1 AUTHORS -=head1 AUTHOR +Sebastian Riedel, -Sebastian Riedel, C +Andy Grundman, =head1 COPYRIGHT