NAME
Mojo::Message - HTTP 1.1 Message Base Class
SYNOPSIS
use base 'Mojo::Message';DESCRIPTION
Mojo::Message is an abstract base class for HTTP 1.1 messages as described in RFC 2616 and RFC 2388.
ATTRIBUTES
Mojo::Message implements the following attributes.
buffer
my $buffer = $message->buffer;
$message = $message->buffer(Mojo::ByteStream->new);Input buffer for parsing.
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.
dom_class
my $class = $message->dom_class;
$message = $message->dom_class('Mojo::DOM');Class to be used for DOM manipulation, defaults to Mojo::DOM. Note that this attribute is EXPERIMENTAL and might change without warning!
json_class
my $class = $message->json_class;
$message = $message->json_class('Mojo::JSON');Class to be used for JSON deserialization with json, defaults to Mojo::JSON. Note that this attribute is EXPERIMENTAL and might change without warning!
major_version
my $major_version = $message->major_version;
$message = $message->major_version(1);Major version, defaults to 1.
max_line_size
my $size = $message->max_line_size;
$message = $message->max_line_size(1024);Maximum line size in bytes, defaults to 10240. Note that this attribute is EXPERIMENTAL and might change without warning!
max_message_size
my $size = $message->max_message_size;
$message = $message->max_message_size(1024);Maximum message size in bytes, defaults to 5242880. Note that this attribute is EXPERIMENTAL and might change without warning!
minor_version
my $minor_version = $message->minor_version;
$message = $message->minor_version(1);Minor version, defaults to 1.
on_finish
my $cb = $message->on_finish;
$message = $message->on_finish(sub {
my $self = shift;
});Callback called after message building or parsing is finished.
on_progress
my $cb = $message->on_progress;
$message = $message->on_progress(sub {
my $self = shift;
print '+';
});Progress callback.
on_read
my $cb = $message->on_read;
$message = $message->on_read(sub {...});Content parser callback.
$message = $message->on_read(sub {
my ($self, $chunk) = @_;
print $chunk;
});Note that this attribute is EXPERIMENTAL and might change without warning!
METHODS
Mojo::Message inherits all methods from Mojo::Base 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!');
$message = $message->body(sub {...});Helper for simplified content access.
body_params
my $params = $message->body_params;POST parameters.
body_size
my $size = $message->body_size;Size of the body in bytes.
to_string
build
my $string = $message->build;Render whole message.
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.
dom
my $dom = $message->dom;
my $collection = $message->dom('a[href]');Parses content into a Mojo::DOM object and takes an optional selector to perform a find on it right away. Note that this method is EXPERIMENTAL and might change without warning!
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.
finish
$message->finish;Finish dynamic content generation. Note that this method is EXPERIMENTAL and might change without warning!
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 $leftovers = $message->has_leftovers;CHeck if message parser has leftover data in the buffer.
header_size
my $size = $message->header_size;Size of headers in bytes.
headers
my $headers = $message->headers;
$message = $message->headers(Mojo::Headers->new);Header container, defaults to a Mojo::Headers object.
is_chunked
my $chunked = $message->is_chunked;Check if message content is chunked.
is_done
my $done = $message->is_done;Check if parser is done.
is_limit_exceeded
my $limit = $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!
is_multipart
my $multipart = $message->is_multipart;Check if message content is multipart.
json
my $object = $message->json;
my $array = $message->json;Decode JSON message body directly using Mojo::JSON if possible, returns undef otherwise. Note that this method is EXPERIMENTAL and might change without warning!
leftovers
my $bytes = $message->leftovers;Remove leftover data from the parser buffer.
param
my $param = $message->param('foo');
my @params = $message->param('foo');Access GET and POST parameters.
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.
upload
my $upload = $message->upload('foo');
my @uploads = $message->upload('foo');Access file uploads.
uploads
my $uploads = $message->uploads;All file uploads.
version
my $version = $message->version;
$message = $message->version('1.1');HTTP version of message.
write
$message->write('Hello!');
$message->write('Hello!', sub {...});Write dynamic content, the optional drain callback will be invoked once all data has been written. Note that this method is EXPERIMENTAL and might change without warning!
write_chunk
$message->write_chunk('Hello!');
$message->write_chunk('Hello!', sub {...});Write chunked content, the optional drain callback will be invoked once all data has been written. Note that this method is EXPERIMENTAL and might change without warning!