LWPx::TimedHTTP performs an HTTP request exactly the same as LWP does normally
except for the fact that it times each stage of the request and then inserts the
results as header.
It's useful for debugging where abouts in a connection slow downs are occuring.
Mason is a powerful Perl-based templating system, designed to generate dynamic
content of all kinds.
Unlike many templating systems, Mason does not attempt to invent an alternate,
"easier" syntax for templates. It provides a set of syntax and features specific
to template creation, but underneath it is still clearly and proudly
recognizable as Perl.
Mason is most often used for generating web pages. It has a companion web
framework, Poet, designed to take maximum advantage of its routing and content
generation features. It can also be used as the templating layer for web
frameworks such as Catalyst and Dancer.
Maypole is a Perl framework for MVC-oriented web applications,
similar to Jakarta's Struts. Maypole is designed to minimize coding
requirements for creating simple web interfaces to databases, while
remaining flexible enough to support enterprise web applications.
MasonX::Interp::WithCallbacks subclasses HTML::Mason::Interp in order to
provide a Mason callback system built on Params::CallbackRequest. Callbacks
may be either code references provided to the C<new()> constructor, or methods
defined in subclasses of Params::Callback. Callbacks are triggered either for
every request or by specially named keys in the Mason request arguments, and
all callbacks are executed at the beginning of a request, just before Mason
creates and executes the request component stack.
This module brings support for a sort of plugin architecture based on
Params::CallbackRequest to Mason. Mason then executes code before executing
any components. This approach allows you to carry out logical processing of
data submitted from a form, to affect the contents of the Mason request
arguments (and thus the %ARGS hash in components), and even to redirect or
abort the request before Mason handles it.
This module prints per-component profiling information to STDERR (usually
directed to the Apache error log). Its output looks like this:
=Mason= 127.0.0.1 - /NoAuth/webrt.css BEGINS {{{
=Mason= 127.0.0.1 - /NoAuth/webrt.css {{{
=Mason= 127.0.0.1 - /Elements/Callback {{{
=Mason= 127.0.0.1 - /Elements/Callback }}} 0.0008
=Mason= 127.0.0.1 - /NoAuth/webrt.css }}} 0.0072
=Mason= 127.0.0.1 - /NoAuth/webrt.css }}} ENDS
Each row contains five whitespace-separated fields: =Mason=, remote IP address,
-, indented component name, and how many seconds did it take to process that
component, including all subcomponents called by it.
The beginning and end of the initial request is represented by the special time
fields BEGINS and ENDS.
This module provides a interface between HTML::Mason and Apache::Session, in
effect, providing full session and cooking handling from within HTML::Mason.
When run under the ApacheHandler module, this module attempts to first use
Apache::Cookie for cookie-handling. Otherwise it uses CGI::Cookie as a
fallback.
This module accepts quite a number of parameters, most of which are simply
passed through to Apache::Session. For this reason, you are advised to
familiarize yourself with the Apache::Session documentation before
attempting to configure this module.
Use 'perldoc MasonX::Request::WithApacheSession' for information on how to
use the module.
MasonX::Request::WithApacheSession was written by Dave Rolsky.
MasonX::WebApp works with Mason to let you do processing before Mason is ever
invoked. There are a number of things that one might want to do:
* Argument munging
You might want to make sure all incoming arguments are UTF-8 encoded.
Or you might want to create some objects which Mason will see as
incoming arguments. For example, a "user_id" parameter could be turned
into a user object.
* Handle requests without Mason
If you're not generating output for the browser other than a redirect,
then there's no reason to use Mason. You can use a MasonX::WebApp
subclass to handle all form submissions, for example.
This has the added benefit of making it easier to preload this code
once during server startup.
* And others ...
Track sessions and, optionally, users
McBain::WithPSGI turns your McBain API into a RESTful PSGI web service based on
Plack, thus making McBain a web application framework.
The created web service will be a JSON-in JSON-out service. Requests to your
application are expected to have a Content-Type of application/json;
charset=UTF-8. The JSON body of a request will be the payload. The results of
the API will be formatted into JSON as well.
McBain is a framework for building powerful APIs and applications. Writing an
API with McBain provides the following benefits:
* Lightweight-ness
* Portability
* Auto-validation
* Self-documentation
* Modularity and flexibility