Mojo::Message - HTTP message base class
package Mojo::Message::MyMessage; use Mojo::Base 'Mojo::Message'; sub cookies {...} sub extract_start_line {...} sub get_start_line_chunk {...}
Mojo::Message is an abstract base class for HTTP messages based on RFC 2616 as well as RFC 2388.
Mojo::Message inherits all events from Mojo::EventEmitter and can emit the following new ones.
$msg->on(finish => sub { my $msg = shift; ... });
Emitted after message building or parsing is finished.
my $before = time; $msg->on(finish => sub { my $msg = shift; $msg->headers->header('X-Parser-Time' => time - $before); });
$msg->on(progress => sub { my $msg = shift; ... });
Emitted when message building or parsing makes progress.
# Building $msg->on(progress => sub { my ($msg, $state, $offset) = @_; say qq{Building "$state" at offset $offset}; }); # Parsing $msg->on(progress => sub { my $msg = shift; return unless my $len = $msg->headers->content_length; my $size = $msg->content->progress; say 'Progress: ', $size == $len ? 100 : int($size / ($len / 100)), '%'; });
Mojo::Message implements the following attributes.
my $msg = $msg->content; $msg = $msg->content(Mojo::Content::Single->new);
Message content, defaults to a Mojo::Content::Single object.
my $charset = $msg->default_charset; $msg = $msg->default_charset('UTF-8');
Default charset used for form-data parsing, defaults to UTF-8.
UTF-8
my $size = $msg->max_line_size; $msg = $msg->max_line_size(1024);
Maximum start line size in bytes, defaults to the value of the MOJO_MAX_LINE_SIZE environment variable or 10240.
10240
my $size = $msg->max_message_size; $msg = $msg->max_message_size(1024);
Maximum message size in bytes, defaults to the value of the MOJO_MAX_MESSAGE_SIZE environment variable or 10485760. Setting the value to 0 will allow messages of indefinite size. Note that increasing this value can also drastically increase memory usage, should you for example attempt to parse an excessively large message body with the "body_params", "dom" or "json" methods.
10485760
0
my $version = $msg->version; $msg = $msg->version('1.1');
HTTP version of message, defaults to 1.1.
1.1
Mojo::Message inherits all methods from Mojo::EventEmitter and implements the following new ones.
my $bytes = $msg->body; $msg = $msg->body('Hello!');
Slurp or replace "content", Mojo::Content::MultiPart will be automatically downgraded to Mojo::Content::Single.
my $params = $msg->body_params;
POST parameters extracted from application/x-www-form-urlencoded or multipart/form-data message body, usually a Mojo::Parameters object. Note that this method caches all data, so it should not be called before the entire message body has been received. Parts of the message body need to be loaded into memory to parse POST parameters, so you have to make sure it is not excessively large.
application/x-www-form-urlencoded
multipart/form-data
# Get POST parameter value say $msg->body_params->param('foo');
my $size = $msg->body_size;
Content size in bytes.
my $bytes = $msg->build_body;
Render whole body.
my $bytes = $msg->build_headers;
Render all headers.
my $bytes = $msg->build_start_line;
Render start line.
my $cookie = $msg->cookie('foo'); my @cookies = $msg->cookie('foo');
Access message cookies, usually Mojo::Cookie::Request or Mojo::Cookie::Response objects. Note that this method caches all data, so it should not be called before all headers have been received.
# Get cookie value say $msg->cookie('foo')->value;
my $cookies = $msg->cookies;
Access message cookies. Meant to be overloaded in a subclass.
my $dom = $msg->dom; my $collection = $msg->dom('a[href]');
Turns message body into a Mojo::DOM object and takes an optional selector to perform a find on it right away, which returns a Mojo::Collection object. Note that this method caches all data, so it should not be called before the entire message body has been received. The whole message body needs to be loaded into memory to parse it, so you have to make sure it is not excessively large.
find
# Perform "find" right away say $msg->dom('h1, h2, h3')->text; # Use everything else Mojo::DOM has to offer say $msg->dom->at('title')->text; say $msg->dom->html->body->children->type->uniq;
my $err = $msg->error; my ($err, $code) = $msg->error; $msg = $msg->error('Parser error'); $msg = $msg->error('Parser error', 500);
Error and code.
my $bool = $msg->extract_start_line(\$str);
Extract start line from string. Meant to be overloaded in a subclass.
$msg = $msg->finish;
Finish message parser/generator.
$msg = $msg->fix_headers;
Make sure message has all required headers.
my $bytes = $msg->get_body_chunk($offset);
Get a chunk of body data starting from a specific position.
my $bytes = $msg->get_header_chunk($offset);
Get a chunk of header data, starting from a specific position.
my $bytes = $msg->get_start_line_chunk($offset);
Get a chunk of start line data starting from a specific position. Meant to be overloaded in a subclass.
my $size = $msg->header_size;
Size of headers in bytes.
my $headers = $msg->headers;
Message headers, usually a Mojo::Headers object.
my $bool = $msg->is_finished;
Check if message parser/generator is finished.
my $bool = $msg->is_limit_exceeded;
Check if message has exceeded "max_line_size" or "max_message_size".
my $hash = $msg->json; my $array = $msg->json; my $value = $msg->json('/foo/bar');
Decode JSON message body directly using Mojo::JSON if possible, returns undef otherwise. An optional JSON Pointer can be used to extract a specific value with Mojo::JSON::Pointer. Note that this method caches all data, so it should not be called before the entire message body has been received. The whole message body needs to be loaded into memory to parse it, so you have to make sure it is not excessively large.
undef
# Extract JSON values say $msg->json->{foo}{bar}[23]; say $msg->json('/foo/bar/23');
my @names = $msg->param; my $foo = $msg->param('foo'); my @foo = $msg->param('foo');
Access POST parameters. Note that this method caches all data, so it should not be called before the entire message body has been received. Parts of the message body need to be loaded into memory to parse POST parameters, so you have to make sure it is not excessively large.
$msg = $msg->parse('HTTP/1.1 200 OK...');
Parse message chunk.
my $size = $msg->start_line_size;
Size of the start line in bytes.
my $str = $msg->text;
Retrieve "body" and try to decode it if a charset could be extracted with "charset" in Mojo::Content.
my $str = $msg->to_string;
Render whole message.
my $upload = $msg->upload('foo'); my @uploads = $msg->upload('foo');
Access multipart/form-data file uploads, usually Mojo::Upload objects. Note that this method caches all data, so it should not be called before the entire message body has been received.
# Get content of uploaded file say $msg->upload('foo')->asset->slurp;
my $uploads = $msg->uploads;
All multipart/form-data file uploads, usually Mojo::Upload objects.
Mojolicious, Mojolicious::Guides, http://mojolicio.us.
To install Mojolicious, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Mojolicious
CPAN shell
perl -MCPAN -e shell install Mojolicious
For more information on module installation, please visit the detailed CPAN module installation guide.