Mojo::Message - HTTP 1.1 message base class
use Mojo::Base 'Mojo::Message';
Mojo::Message is an abstract base class for HTTP 1.1 messages as described in RFC 2616 and RFC 2388.
Mojo::Message can emit the following events.
finish
$message->on(finish => sub { my $message = shift; ... });
Emitted after message building or parsing is finished.
my $before = time; $message->on(finish => sub { my $message = shift; $message->headers->header('X-Parser-Time' => time - $before); });
progress
$message->on(progress => sub { my $message = shift; ... });
Emitted when message building or parsing makes progress.
$message->on(progress => sub { my $message = shift; return unless my $len = $message->headers->content_length; my $size = $message->content->progress; say 'Progress: ', $size == $len ? 100 : int($size / ($len / 100)), '%'; });
Mojo::Message implements the following attributes.
content
my $message = $message->content; $message = $message->content(Mojo::Content::Single->new);
Content container, defaults to a Mojo::Content::Single object.
default_charset
my $charset = $message->default_charset; $message = $message->default_charset('UTF-8');
Default charset used for form data parsing, defaults to UTF-8.
UTF-8
dom_class
my $class = $message->dom_class; $message = $message->dom_class('Mojo::DOM');
Class to be used for DOM manipulation with the dom method, defaults to Mojo::DOM.
dom
json_class
my $class = $message->json_class; $message = $message->json_class('Mojo::JSON');
Class to be used for JSON deserialization with the json method, defaults to Mojo::JSON.
json
max_message_size
my $size = $message->max_message_size; $message = $message->max_message_size(1024);
Maximum message size in bytes, defaults to the value of MOJO_MAX_MESSAGE_SIZE or 5242880.
MOJO_MAX_MESSAGE_SIZE
5242880
version
my $version = $message->version; $message = $message->version('1.1');
HTTP version of message.
Mojo::Message inherits all methods from Mojo::EventEmitter and implements the following new ones.
at_least_version
my $success = $message->at_least_version('1.1');
Check if message is at least a specific version.
body
my $string = $message->body; $message = $message->body('Hello!'); my $cb = $message->body(sub {...});
Access content data or replace all subscribers of the read event.
read
$message->body(sub { my ($message, $chunk) = @_; say "Streaming: $chunk"; });
body_params
my $params = $message->body_params;
POST parameters, usually a Mojo::Parameters object.
POST
say $message->body_params->param('foo');
body_size
my $size = $message->body_size;
Alias for "body_size" in Mojo::Content.
build_body
my $string = $message->build_body;
Render whole body.
build_headers
my $string = $message->build_headers;
Render all headers.
build_start_line
my $string = $message->build_start_line;
Render start line.
cookie
my $cookie = $message->cookie('foo'); my @cookies = $message->cookie('foo');
Access message cookies, usually Mojo::Cookie::Request or Mojo::Cookie::Response objects.
say $message->cookie('foo')->value;
my $dom = $message->dom; my $collection = $message->dom('a[href]');
Turns content into a Mojo::DOM object and takes an optional selector to perform a find on it right away, which returns a collection.
find
# Perform "find" right away $message->dom('h1, h2, h3')->each(sub { say $_->text }); # Use everything else Mojo::DOM has to offer say $message->dom->at('title')->text; $message->dom->html->body->children->each(sub { say $_->type });
error
my $message = $message->error; my ($message, $code) = $message->error; $message = $message->error('Parser error.'); $message = $message->error('Parser error.', 500);
Parser errors and codes.
fix_headers
$message = $message->fix_headers;
Make sure message has all required headers for the current HTTP version.
get_body_chunk
my $string = $message->get_body_chunk($offset);
Get a chunk of body data starting from a specific position.
get_header_chunk
my $string = $message->get_header_chunk($offset);
Get a chunk of header data, starting from a specific position.
get_start_line_chunk
my $string = $message->get_start_line_chunk($offset);
Get a chunk of start line data starting from a specific position.
has_leftovers
my $success = $message->has_leftovers;
Alias for "has_leftovers" in Mojo::Content.
header_size
my $size = $message->header_size;
Size of headers in bytes.
headers
my $headers = $message->headers;
Alias for "headers" in Mojo::Content.
say $message->headers->content_type;
is_chunked
my $success = $message->is_chunked;
Alias for "is_chunked" in Mojo::Content.
is_dynamic
my $success = $message->is_dynamic;
Alias for "is_dynamic" in Mojo::Content. Note that this method is EXPERIMENTAL and might change without warning!
is_finished
my $success = $message->is_finished;
Check if parser is finished.
is_limit_exceeded
my $success = $message->is_limit_exceeded;
Check if message has exceeded max_line_size or max_message_size. Note that this method is EXPERIMENTAL and might change without warning!
max_line_size
is_multipart
my $success = $message->is_multipart;
Alias for "is_multipart" in Mojo::Content.
my $object = $message->json; my $array = $message->json; my $value = $message->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.
undef
say $message->json->{foo}->{bar}->[23]; say $message->json('/foo/bar/23');
leftovers
my $bytes = $message->leftovers;
Alias for "leftovers" in Mojo::Content.
$message->max_line_size(1024);
Alias for "max_line_size" in Mojo::Headers. Note that this method is EXPERIMENTAL and might change without warning!
param
my $param = $message->param('foo'); my @params = $message->param('foo');
Access GET and POST parameters.
GET
parse
$message = $message->parse('HTTP/1.1 200 OK...');
Parse message chunk.
parse_until_body
$message = $message->parse_until_body('HTTP/1.1 200 OK...');
Parse message chunk until the body is reached.
start_line_size
my $size = $message->start_line_size;
Size of the start line in bytes.
to_string
my $string = $message->to_string;
Render whole message.
upload
my $upload = $message->upload('foo'); my @uploads = $message->upload('foo');
Access multipart/form-data file uploads, usually Mojo::Upload objects.
multipart/form-data
say $message->upload('foo')->asset->slurp;
uploads
my $uploads = $message->uploads;
All multipart/form-data file uploads, usually Mojo::Upload objects.
say $message->uploads->[2]->filename;
write
$message->write('Hello!'); $message->write('Hello!', sub {...});
Alias for "write" in Mojo::Content.
write_chunk
$message->write_chunk('Hello!'); $message->write_chunk('Hello!', sub {...});
Alias for "write_headers" in Mojo::Content.
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.