| Plack documentation | Contained in the Plack distribution. |
Plack::Component - Base class for PSGI endpoints
package Plack::App::Foo;
use parent qw( Plack::Component );
sub call {
my($self, $env) = @_;
# Do something with $env
my $res = ...; # create a response ...
# return the response
return $res;
}
Plack::Component is the base class shared between Plack::Middleware and Plack::App::* modules. If you are writing middleware, you should inherit from Plack::Middleware, but if you are writing a Plack::App::* you should inherit from this directly.
You are expected to implement a call method in your component. This
is where all the work gets done. It receives the PSGI $env hash-ref
as an argument and is expected to return a proper PSGI response value.
The constructor accepts either a hash or a hash-ref and uses that to create the instance with. It will call no other methods and simply return the instance that is created.
This method is called by to_app and is meant as a hook to be used to
prepare your component before it is packaged as a PSGI $app.
This is the method used in several parts of the Plack infrastructure to
convert your component into a PSGI $app. You should not ever need to
override this method, it is recommended to use prepare_app and call
instead.
This is a wrapper for response_cb in Plack::Util. See
RESPONSE CALLBACK in Plack::Middleware for details.
Objects for the derived classes (Plack::App::* or
Plack::Middleware::*) are created at the PSGI application compile
phase using new, prepare_app and to_app, and the created
object persists during the web server lifecycle, unless it is running
on the non-persistent environment like CGI. call is invoked against
the same object whenever a new request comes in.
You can check if it is running in a persistent environment by checking
psgi.run_once key in the $env being true (non-persistent) or
false (persistent), but it is best for you to write your middleware
safely for a persistent environment. To accomplish that, you should
avoid saving per-request data like $env in your object.
The Plack::Middleware module used to inherit from Class::Accessor::Fast, which has been removed in favor of the Plack::Util::Accessor module. When developing new components it is recommended to use Plack::Util::Accessor like so:
use Plack::Util::Accessor qw( foo bar baz );
However, in order to keep backwards compatibility this module provides a
mk_accessors method similar to Class::Accessor::Fast. New code should
not use this and use Plack::Util::Accessor instead.
| Plack documentation | Contained in the Plack distribution. |
package Plack::Component; use strict; use warnings; use Carp (); use Plack::Util; use overload '&{}' => sub { shift->to_app(@_) }, fallback => 1; sub new { my $proto = shift; my $class = ref $proto || $proto; my $self; if (@_ == 1 && ref $_[0] eq 'HASH') { $self = bless {%{$_[0]}}, $class; } else { $self = bless {@_}, $class; } $self; } # NOTE: # this is for back-compat only, # future modules should use # Plack::Util::Accessor directly # or their own favorite accessor # generator. # - SL sub mk_accessors { my $self = shift; Plack::Util::Accessor::mk_accessors( ref( $self ) || $self, @_ ) } sub prepare_app { return } sub to_app { my $self = shift; $self->prepare_app; return sub { $self->call(@_) }; } sub response_cb { my($self, $res, $cb) = @_; Plack::Util::response_cb($res, $cb); } 1; __END__