package Catalyst::Engine;
-use strict;
-use base 'Class::Accessor::Fast';
+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 URI::QueryParam;
-use Scalar::Util ();
+
+use namespace::clean -except => 'meta';
+
+has env => (is => 'rw');
# input position and length
-__PACKAGE__->mk_accessors(qw/read_position read_length/);
+has read_length => (is => 'rw');
+has read_position => (is => 'rw');
-# Stringify to class
-use overload '""' => sub { return ref shift }, fallback => 1;
+has _prepared_write => (is => 'rw');
# Amount of data to read from input on each pass
our $CHUNKSIZE = 64 * 1024;
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 );
- }
+ if ( blessed($body) && $body->can('read') or ref($body) eq 'GLOB' ) {
+ my $got;
+ do {
+ $got = read $body, my ($buffer), $CHUNKSIZE;
+ $got = 0 unless $self->write( $c, $buffer );
+ } while $got > 0;
+
close $body;
}
else {
my ( $self, $c ) = @_;
my @cookies;
+ my $response = $c->response;
- foreach my $name ( keys %{ $c->response->cookies } ) {
+ foreach my $name (keys %{ $response->cookies }) {
- my $val = $c->response->cookies->{$name};
+ my $val = $response->cookies->{$name};
my $cookie = (
- Scalar::Util::blessed($val)
+ blessed($val)
? $val
: CGI::Simple::Cookie->new(
-name => $name,
-expires => $val->{expires},
-domain => $val->{domain},
-path => $val->{path},
- -secure => $val->{secure} || 0
+ -secure => $val->{secure} || 0,
+ -httponly => $val->{httponly} || 0,
)
);
}
for my $cookie (@cookies) {
- $c->res->headers->push_header( 'Set-Cookie' => $cookie );
+ $response->headers->push_header( 'Set-Cookie' => $cookie );
}
}
=head2 $self->finalize_error($c)
-Output an apropriate error message, called if there's an error in $c
+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 _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;
+<h2><a href="#" onclick="toggleDump('dump_$i'); return false">%s</a></h2>
+<div id="dump_$i">
+ <pre wrap="">%s</pre>
+</div>
+EOF
+}
+
sub finalize_error {
my ( $self, $c ) = @_;
$c->res->content_type('text/html; charset=utf-8');
- my $name = $c->config->{name} || join(' ', split('::', ref $c));
+ my $name = ref($c)->config->{name} || join(' ', split('::', ref $c));
my ( $title, $error, $infos );
if ( $c->debug ) {
$name = "<h1>$name</h1>";
# Don't show context in the dump
- delete $c->req->{_context};
- delete $c->res->{_context};
+ $c->req->_clear_context;
+ $c->res->_clear_context;
# Don't show body parser in the dump
- delete $c->req->{_body};
-
- # Don't show response header state in dump
- delete $c->res->{_finalized_headers};
+ $c->req->_clear_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;
-<h2><a href="#" onclick="toggleDump('dump_$i'); return false">%s</a></h2>
-<div id="dump_$i">
- <pre wrap="">%s</pre>
-</div>
-EOF
+ push @infos, $self->_dump_error_page_element($i, $dump);
$i++;
}
$infos = join "\n", @infos;
$error = '';
$infos = <<"";
<pre>
+(es) Por favor inténtelo de nuevo más tarde
(en) Please come back later
(fr) SVP veuillez revenir plus tard
(de) Bitte versuchen sie es spaeter nocheinmal
(no) Vennligst prov igjen senere
(dk) Venligst prov igen senere
(pl) Prosze sprobowac pozniej
+(pt) Por favor volte mais tarde
+(ru) Попробуйте еще раз позже
+(ua) Спробуйте ще раз пізніше
</pre>
$name = '';
}
/* from http://users.tkk.fi/~tkarvine/linux/doc/pre-wrap/pre-wrap-css3-mozilla-opera-ie.html */
/* Browser specific (not valid) styles to make preformatted text wrap */
- pre {
+ pre {
white-space: pre-wrap; /* css-3 */
white-space: -moz-pre-wrap; /* Mozilla, since 1999 */
white-space: -pre-wrap; /* Opera 4-6 */
</html>
- # 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 );
# Return 500
=cut
-sub finalize_read {
- my ( $self, $c ) = @_;
-
- undef $self->{_prepared_read};
-}
+sub finalize_read { }
=head2 $self->finalize_uploads($c)
sub finalize_uploads {
my ( $self, $c ) = @_;
- if ( keys %{ $c->request->uploads } ) {
- for my $key ( keys %{ $c->request->uploads } ) {
- my $upload = $c->request->uploads->{$key};
- unlink map { $_->tempname }
- grep { -e $_->tempname }
- ref $upload eq 'ARRAY' ? @{$upload} : ($upload);
- }
+ # 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));
}
+
}
=head2 $self->prepare_body($c)
sub prepare_body {
my ( $self, $c ) = @_;
-
- my $length = $c->request->header('Content-Length') || 0;
-
- $self->read_length( $length );
- if ( $length > 0 ) {
- unless ( $c->request->{_body} ) {
- my $type = $c->request->header('Content-Type');
- $c->request->{_body} = HTTP::Body->new( $type, $length );
- $c->request->{_body}->{tmpdir} = $c->config->{uploadtmp}
- if exists $c->config->{uploadtmp};
+ my $appclass = ref($c) || $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->cleanup(1); # Make extra sure!
+ $request->_body->tmpdir( $appclass->config->{uploadtmp} )
+ if exists $appclass->config->{uploadtmp};
}
-
- while ( my $buffer = $self->read($c) ) {
+
+ # Check for definedness as you could read '0'
+ while ( defined ( my $buffer = $self->read($c) ) ) {
$c->prepare_body_chunk($buffer);
}
}
else {
# Defined but will cause all body code to be skipped
- $c->request->{_body} = 0;
+ $c->request->_body(0);
}
}
sub prepare_body_chunk {
my ( $self, $c, $chunk ) = @_;
- $c->request->{_body}->add($chunk);
+ $c->request->_body->add($chunk);
}
=head2 $self->prepare_body_parameters($c)
-Sets up parameters from body.
+Sets up parameters from body.
=cut
sub prepare_body_parameters {
my ( $self, $c ) = @_;
-
- return unless $c->request->{_body};
-
- $c->request->body_parameters( $c->request->{_body}->param );
+
+ return unless $c->request->_body;
+
+ $c->request->body_parameters( $c->request->_body->param );
}
=head2 $self->prepare_connection($c)
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 %{ $c->request->query_parameters } ) {
- my $param = $c->request->query_parameters->{$name};
- $param = ref $param eq 'ARRAY' ? [ @{$param} ] : $param;
- $c->request->parameters->{$name} = $param;
+ foreach my $name (keys %$query_parameters) {
+ my $param = $query_parameters->{$name};
+ $parameters->{$name} = ref $param eq 'ARRAY' ? [ @$param ] : $param;
}
# Merge query and body parameters
- foreach my $name ( keys %{ $c->request->body_parameters } ) {
- my $param = $c->request->body_parameters->{$name};
- $param = ref $param eq 'ARRAY' ? [ @{$param} ] : $param;
- if ( my $old_param = $c->request->parameters->{$name} ) {
- if ( ref $old_param eq 'ARRAY' ) {
- push @{ $c->request->parameters->{$name} },
- ref $param eq 'ARRAY' ? @$param : $param;
- }
- else { $c->request->parameters->{$name} = [ $old_param, $param ] }
+ 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));
}
- else { $c->request->parameters->{$name} = $param }
+ $parameters->{$name} = @values > 1 ? \@values : $values[0];
}
}
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;
+ }
+
+ my %query;
+
# replace semi-colons
$query_string =~ s/;/&/g;
- my $u = URI->new( '', 'http' );
- $u->query($query_string);
- for my $key ( $u->query_param ) {
- my @vals = $u->query_param($key);
- $c->request->query_parameters->{$key} = @vals > 1 ? [@vals] : $vals[0];
+ my @params = grep { length $_ } 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;
+ }
}
+
+ $c->request->query_parameters( \%query );
}
=head2 $self->prepare_read($c)
sub prepare_read {
my ( $self, $c ) = @_;
- # Reset the read position
+ # 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 );
}
=head2 $self->prepare_request(@arguments)
sub prepare_uploads {
my ( $self, $c ) = @_;
-
- return unless $c->request->{_body};
-
- my $uploads = $c->request->{_body}->upload;
- for my $name ( keys %$uploads ) {
+
+ 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};
- $files = ref $files eq 'ARRAY' ? $files : [$files];
my @uploads;
- for my $upload (@$files) {
- my $u = Catalyst::Request::Upload->new;
- $u->headers( HTTP::Headers->new( %{ $upload->{headers} } ) );
- $u->type( $u->headers->content_type );
- $u->tempname( $upload->{tempname} );
- $u->size( $upload->{size} );
- $u->filename( $upload->{filename} );
+ 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 => scalar $headers->content_type,
+ headers => $headers,
+ tempname => $upload->{tempname},
+ filename => $upload->{filename},
+ );
push @uploads, $u;
}
- $c->request->uploads->{$name} = @uploads > 1 ? \@uploads : $uploads[0];
+ $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 $c->request->parameters->{$name}) {
- if (ref $c->request->parameters->{$name} eq 'ARRAY') {
- push @{ $c->request->parameters->{$name} }, @filenames;
+ if (exists $parameters->{$name}) {
+ if (ref $parameters->{$name} eq 'ARRAY') {
+ push @{ $parameters->{$name} }, @filenames;
}
else {
- $c->request->parameters->{$name} =
- [ $c->request->parameters->{$name}, @filenames ];
+ $parameters->{$name} = [ $parameters->{$name}, @filenames ];
}
}
else {
- $c->request->parameters->{$name} =
- @filenames > 1 ? \@filenames : $filenames[0];
+ $parameters->{$name} = @filenames > 1 ? \@filenames : $filenames[0];
}
}
}
=head2 $self->read($c, [$maxlength])
+Reads from the input stream by calling C<< $self->read_chunk >>.
+
+Maintains the read_length and read_position counters as data is read.
+
=cut
sub read {
my ( $self, $c, $maxlength ) = @_;
- unless ( $self->{_prepared_read} ) {
- $self->prepare_read($c);
- $self->{_prepared_read} = 1;
- }
-
my $remaining = $self->read_length - $self->read_position;
$maxlength ||= $CHUNKSIZE;
my $readlen = ( $remaining > $maxlength ) ? $maxlength : $remaining;
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?
+ $self->finalize_read;
+ return;
+ }
$self->read_position( $self->read_position + $rc );
return $buffer;
}
=head2 $self->read_chunk($c, $buffer, $length)
-Each engine inplements read_chunk as its preferred way of reading a chunk
-of data.
+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
=head2 $self->write($c, $buffer)
-Writes the buffer to the client. Can only be called once for a request.
+Writes the buffer to the client.
=cut
sub write {
my ( $self, $c, $buffer ) = @_;
- unless ( $self->{_prepared_write} ) {
+ unless ( $self->_prepared_write ) {
$self->prepare_write($c);
- $self->{_prepared_write} = 1;
+ $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;
}
- print STDOUT $buffer;
+ 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 unescape_uri {
+ my ( $self, $str ) = @_;
+
+ $str =~ s/(?:%([0-9A-Fa-f]{2})|\+)/defined $1 ? chr(hex($1)) : ' '/eg;
+
+ return $str;
+}
=head2 $self->finalize_output
<obsolete>, see finalize_body
-=head1 AUTHORS
+=head2 $self->env
-Sebastian Riedel, <sri@cpan.org>
+Hash containing environment variables including many special variables inserted
+by WWW server - like SERVER_*, REMOTE_*, HTTP_* ...
+
+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 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.
+
+=head1 AUTHORS
-Andy Grundman, <andy@hybridized.org>
+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