Mojo::Content(3pm)

NAME
Mojo::Content - HTTP content base class

SYNOPSIS
  package Mojo::Content::MyContent;
  use Mojo::Base 'Mojo::Content';

  sub body_contains  {...}
  sub body_size      {...}
  sub get_body_chunk {...}

DESCRIPTION
Mojo::Content is an abstract base class for HTTP content containers, based on RFC 7230 <https://tools.ietf.org/html/rfc7230> and RFC 7231 <https://tools.ietf.org/html/rfc7231>, like Mojo::Content::MultiPart and Mojo::Content::Single.

EVENTS
Mojo::Content inherits all events from Mojo::EventEmitter and can emit the following new ones.

  body
  $content->on(body => sub ($content) {...});

Emitted once all headers have been parsed and the body starts.

  $content->on(body => sub ($content) {
    $content->auto_upgrade(0) if $content->headers->header('X-No-MultiPart');
  });

  drain
  $content->on(drain => sub ($content, $offset) {...});

Emitted once all data has been written.

  $content->on(drain => sub ($content) {
    $content->write_chunk(time);
  });

  read
  $content->on(read => sub ($content, $bytes) {...});

Emitted when a new chunk of content arrives.

  $content->on(read => sub ($content, $bytes) {
    say "Streaming: $bytes";
  });

  sse
  $content->on(sse => sub ($content, $event) {...});

Emitted when a new Server-Sent Event (SSE) connection has been established and for each new event that arrives. Note that this event is EXPERIMENTAL and may change without warning!

  $content->on(sse => sub ($content, $event) {
    if ($event) { say "Type: $event->{type}, Data: $event->{data}" }
    else        { say "SSE connection established" }
  });

ATTRIBUTES
Mojo::Content implements the following attributes.

  auto_decompress
  my $bool = $content->auto_decompress;
  $content = $content->auto_decompress($bool);

Decompress content automatically if "is_compressed" is true.

  auto_relax
  my $bool = $content->auto_relax;
  $content = $content->auto_relax($bool);

Try to detect when relaxed parsing is necessary.

  headers
  my $headers = $content->headers;
  $content    = $content->headers(Mojo::Headers->new);

Content headers, defaults to a Mojo::Headers object.

  max_buffer_size
  my $size = $content->max_buffer_size;
  $content = $content->max_buffer_size(1024);

Maximum size in bytes of buffer for content parser, defaults to the value of the "MOJO_MAX_BUFFER_SIZE" environment variable or 262144 (256KiB).

  max_leftover_size
  my $size = $content->max_leftover_size;
  $content = $content->max_leftover_size(1024);

Maximum size in bytes of buffer for pipelined HTTP requests, defaults to the value of the "MOJO_MAX_LEFTOVER_SIZE" environment variable or 262144 (256KiB).

  relaxed
  my $bool = $content->relaxed;
  $content = $content->relaxed($bool);

Activate relaxed parsing for responses that are terminated with a connection close.

  skip_body
  my $bool = $content->skip_body;
  $content = $content->skip_body($bool);

Skip body parsing and finish after headers.

METHODS
Mojo::Content inherits all methods from Mojo::EventEmitter and implements the following new ones.

  body_contains
  my $bool = $content->body_contains('foo bar baz');

Check if content contains a specific string. Meant to be overloaded in a subclass.

  body_size
  my $size = $content->body_size;

Content size in bytes. Meant to be overloaded in a subclass.

  boundary
  my $boundary = $content->boundary;

Extract multipart boundary from "Content-Type" header.

  charset
  my $charset = $content->charset;

Extract charset from "Content-Type" header.

  clone
  my $clone = $content->clone;

Return a new Mojo::Content object cloned from this content if possible, otherwise return "undef".

  generate_body_chunk
  my $bytes = $content->generate_body_chunk(0);

Generate dynamic content.

  get_body_chunk
  my $bytes = $content->get_body_chunk(0);

Get a chunk of content starting from a specific position. Meant to be overloaded in a subclass.

  get_header_chunk
  my $bytes = $content->get_header_chunk(13);

Get a chunk of the headers starting from a specific position. Note that this method finalizes the content.

  header_size
  my $size = $content->header_size;

Size of headers in bytes. Note that this method finalizes the content.

  headers_contain
  my $bool = $content->headers_contain('foo bar baz');

Check if headers contain a specific string. Note that this method finalizes the content.

  is_chunked
  my $bool = $content->is_chunked;

Check if "Transfer-Encoding" header indicates chunked transfer encoding.

  is_compressed
  my $bool = $content->is_compressed;

Check "Content-Encoding" header for "gzip" value.

  is_dynamic
  my $bool = $content->is_dynamic;

Check if content will be dynamically generated, which prevents "clone" from working.

  is_finished
  my $bool = $content->is_finished;

Check if parser is finished.

  is_limit_exceeded
  my $bool = $content->is_limit_exceeded;

Check if buffer has exceeded "max_buffer_size".

  is_multipart
  my $bool = $content->is_multipart;

False, this is not a Mojo::Content::MultiPart object.

  is_parsing_body
  my $bool = $content->is_parsing_body;

Check if body parsing started yet.

  is_sse
  my $bool = $content->is_sse;

Check if "Content-Type" header indicates Server-Sent Events (SSE). Note that this method is EXPERIMENTAL and may change without warning!

  leftovers
  my $bytes = $content->leftovers;

Get leftover data from content parser.

  parse
  $content
    = $content->parse("Content-Length: 12\x0d\x0a\x0d\x0aHello World!");

Parse content chunk.

  parse_body
  $content = $content->parse_body('Hi!');

Parse body chunk and skip headers.

  progress
  my $size = $content->progress;

Size of content already received from message in bytes.

  write
  $content = $content->write;
  $content = $content->write('');
  $content = $content->write($bytes);
  $content = $content->write($bytes => sub {...});

Write dynamic content non-blocking, the optional drain callback will be executed once all data has been written. Calling this method without a chunk of data will finalize the "headers" and allow for dynamic content to be written later. You can write an empty chunk of data at any time to end the stream.

  # Make sure previous chunk of data has been written before continuing
  $content->write('He' => sub ($content) {
    $content->write('llo!' => sub ($content) {
      $content->write('');
    });
  });

  write_chunk
  $content = $content->write_chunk;
  $content = $content->write_chunk('');
  $content = $content->write_chunk($bytes);
  $content = $content->write_chunk($bytes => sub {...});

Write dynamic content non-blocking with chunked transfer encoding, the optional drain callback will be executed once all data has been written. Calling this method without a chunk of data will finalize the "headers" and allow for dynamic content to be written later. You can write an empty chunk of data at any time to end the stream.

  # Make sure previous chunk of data has been written before continuing
  $content->write_chunk('He' => sub ($content) {
    $content->write_chunk('llo!' => sub ($content) {
      $content->write_chunk('');
    });
  });

  write_sse
  $content = $content->write_sse;
  $content = $content->write_sse($event);
  $content = $content->write_sse($event => sub {...});

Write Server-Sent Event (SSE) non-blocking, the optional drain callback will be executed once all data has been written. Calling this method without an event will finalize the response headers and allow for events to be written later. Note that this method is EXPERIMENTAL and may change without warning!

SEE ALSO
Mojolicious, Mojolicious::Guides, <https://mojolicious.org>.