X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FResponse.pm;h=f049ebfab77184ed4c5eecf1454ffeee8f1e0e7a;hb=0810283f5e3c710d09ab56ceb8fb0b6bfbe3bbe9;hp=3af1eef965d39a2d42036364d22f904c85a9b8a7;hpb=eb1f4b491f735a82e8f1279e96c5ba4f6bf5365c;p=catagits%2FCatalyst-Runtime.git diff --git a/lib/Catalyst/Response.pm b/lib/Catalyst/Response.pm index 3af1eef..f049ebf 100644 --- a/lib/Catalyst/Response.pm +++ b/lib/Catalyst/Response.pm @@ -9,7 +9,7 @@ with 'MooseX::Emulate::Class::Accessor::Fast'; has _response_cb => ( is => 'ro', - isa => 'CodeRef', + isa => 'CodeRef', writer => '_set_response_cb', clearer => '_clear_response_cb', predicate => '_has_response_cb', @@ -20,28 +20,42 @@ subtype 'Catalyst::Engine::Types::Writer', has _writer => ( is => 'ro', - isa => 'Catalyst::Engine::Types::Writer', - writer => '_set_writer', + isa => 'Catalyst::Engine::Types::Writer', #Pointless since we control how this is built + #writer => '_set_writer', Now that its lazy I think this is safe to remove clearer => '_clear_writer', predicate => '_has_writer', + lazy => 1, + builder => '_build_writer', ); +sub _build_writer { + my $self = shift; + + ## These two lines are probably crap now... + $self->_context->finalize_headers unless + $self->finalized_headers; + + my @headers; + $self->headers->scan(sub { push @headers, @_ }); + + my $writer = $self->_response_cb->([ $self->status, \@headers ]); + $self->_clear_response_cb; + + return $writer; +} + has write_fh => ( is=>'ro', - predicate=>'has_write_fh', + predicate=>'_has_write_fh', lazy=>1, - builder=>'_build_write_fh'); + builder=>'_build_write_fh', +); - sub _build_write_fh { - my $self = shift; - $self->_context->finalize_headers unless - $self->finalized_headers; - $self->_writer; - }; +sub _build_write_fh { shift ->_writer } sub DEMOLISH { my $self = shift; - return if $self->has_write_fh; + return if $self->_has_write_fh; if($self->_has_writer) { $self->_writer->close } @@ -68,6 +82,15 @@ has _context => ( clearer => '_clear_context', ); +before [qw(status headers content_encoding content_length content_type header)] => sub { + my $self = shift; + + $self->_context->log->warn( + "Useless setting a header value after finalize_headers called." . + " Not what you want." ) + if ( $self->finalized_headers && @_ ); +}; + sub output { shift->body(@_) } sub code { shift->status(@_) } @@ -88,29 +111,33 @@ sub write { sub finalize_headers { my ($self) = @_; - - # This is a less-than-pretty hack to avoid breaking the old - # Catalyst::Engine::PSGI. 5.9 Catalyst::Engine sets a response_cb and - # expects us to pass headers to it here, whereas Catalyst::Enngine::PSGI - # just pulls the headers out of $ctx->response in its run method and never - # sets response_cb. So take the lack of a response_cb as a sign that we - # don't need to set the headers. - - return unless $self->_has_response_cb; - - # If we already have a writer, we already did this, so don't do it again - return if $self->_has_writer; - - my @headers; - $self->headers->scan(sub { push @headers, @_ }); - - my $writer = $self->_response_cb->([ $self->status, \@headers ]); - $self->_set_writer($writer); - $self->_clear_response_cb; - return; } +sub from_psgi_response { + my ($self, $psgi_res) = @_; + if(ref $psgi_res eq 'ARRAY') { + my ($status, $headers, $body) = @$psgi_res; + $self->status($status); + $self->headers(HTTP::Headers->new(@$headers)); + $self->body($body); + } elsif(ref $psgi_res eq 'CODE') { + $psgi_res->(sub { + my $response = shift; + my ($status, $headers, $maybe_body) = @$response; + $self->status($status); + $self->headers(HTTP::Headers->new(@$headers)); + if(defined $maybe_body) { + $self->body($maybe_body); + } else { + return $self->write_fh; + } + }); + } else { + die "You can't set a Catalyst response from that, expect a valid PSGI response"; + } +} + =head1 NAME Catalyst::Response - stores output responding to the current client request @@ -148,6 +175,93 @@ you might want to use a L type of object (Something that implements in the same fashion), or a filehandle GLOB. Catalyst will write it piece by piece into the response. +When using a L type of object and no content length has been +already set in the response headers Catalyst will make a reasonable attempt +to determine the size of the Handle. Depending on the implementation of your +handle object, setting the content length may fail. If it is at all possible +for you to determine the content length of your handle object, +it is recommended that you set the content length in the response headers +yourself, which will be respected and sent by Catalyst in the response. + +Please note that the object needs to implement C, not just +C. + +Starting from version 5.90060, when using an L object, you +may want to use L, to delegate the +actual serving to the frontend server. To do so, you need to pass to +C an IO object with a C method. This can be achieved in +two ways. + +Either using L: + + my $fh = IO::File->new($file, 'r'); + Plack::Util::set_io_path($fh, $file); + +Or using L + + my $fh = IO::File::WithPath->new($file, 'r'); + +And then passing the filehandle to body and setting headers, if needed. + + $c->response->body($fh); + $c->response->headers->content_type('text/plain'); + $c->response->headers->content_length(-s $file); + $c->response->headers->last_modified((stat($file))[9]); + +L can be loaded in the application so: + + __PACKAGE__->config( + psgi_middleware => [ + 'XSendfile', + # other middlewares here... + ], + ); + +B that loading the middleware without configuring the +webserver to set the request header C to a supported +type (C for nginx, C for Apache and +Lighttpd), could lead to the disclosure of private paths to malicious +clients setting that header. + +Nginx needs the additional X-Accel-Mapping header to be set in the +webserver configuration, so the middleware will replace the absolute +path of the IO object with the internal nginx path. This is also +useful to prevent a buggy app to server random files from the +filesystem, as it's an internal redirect. + +An nginx configuration for FastCGI could look so: + + server { + server_name example.com; + root /my/app/root; + location /private/repo/ { + internal; + alias /my/app/repo/; + } + location /private/staging/ { + internal; + alias /my/app/staging/; + } + location @proxy { + include /etc/nginx/fastcgi_params; + fastcgi_param SCRIPT_NAME ''; + fastcgi_param PATH_INFO $fastcgi_script_name; + fastcgi_param HTTP_X_SENDFILE_TYPE X-Accel-Redirect; + fastcgi_param HTTP_X_ACCEL_MAPPING /my/app=/private; + fastcgi_pass unix:/my/app/run/app.sock; + } + } + +In the example above, passing filehandles with a local path matching +/my/app/staging or /my/app/repo will be served by nginx. Passing paths +with other locations will lead to an internal server error. + +Setting the body to a filehandle without the C method bypasses +the middleware completely. + +For Apache and Lighttpd, the mapping doesn't apply and setting the +X-Sendfile-Type is enough. + =head2 $res->has_body Predicate which returns true when a body has been set. @@ -308,6 +422,33 @@ the response object to functions that want to write to an L. Writes headers to response if not already written +=head2 from_psgi_response + +Given a PSGI response (either three element ARRAY reference OR coderef expecting +a $responder) set the response from it. + +Properly supports streaming and delayed response and / or async IO if running +under an expected event loop. + +Example: + + package MyApp::Web::Controller::Test; + + use base 'Catalyst::Controller'; + use Plack::App::Directory; + + + my $app = Plack::App::Directory->new({ root => "/path/to/htdocs" }) + ->to_app; + + sub myaction :Local Args { + my ($self, $c) = @_; + $c->res->from_psgi_response($app->($c->req->env)); + } + +Please note this does not attempt to map or nest your PSGI application under +the Controller and Action namespace or path. + =head2 DEMOLISH Ensures that the response is flushed and closed at the end of the