Mojo::Transaction::WebSocket(3p)

NAME
Mojo::Transaction::WebSocket - WebSocket transaction container

SYNOPSIS
  use Mojo::Transaction::WebSocket;

  my $ws = Mojo::Transaction::WebSocket->new;

DESCRIPTION
Mojo::Transaction::WebSocket is a container for WebSocket transactions as described in RFC 6455.

EVENTS
Mojo::Transaction::WebSocket inherits all events from Mojo::Transaction and can emit the following new ones.

  "drain"
  $ws->on(drain => sub {
    my $ws = shift;
    ...
  });

Emitted once all data has been sent.

  $ws->on(drain => sub {
    my $ws = shift;
    $ws->send(time);
  });

  "frame"
  $ws->on(frame => sub {
    my ($ws, $frame) = @_;
    ...
  });

Emitted when a WebSocket frame has been received.

  $ws->on(frame => sub {
    my ($ws, $frame) = @_;
    say "Fin: $frame->[0]";
    say "Rsv1: $frame->[1]";
    say "Rsv2: $frame->[2]";
    say "Rsv3: $frame->[3]";
    say "Op: $frame->[4]";
    say "Payload: $frame->[5]";
  });

  "message"
  $ws->on(message => sub {
    my ($ws, $message) = @_;
    ...
  });

Emitted when a complete WebSocket message has been received.

  $ws->on(message => sub {
    my ($ws, $message) = @_;
    say "Message: $message";
  });

ATTRIBUTES
Mojo::Transaction::WebSocket inherits all attributes from Mojo::Transaction and implements the following new ones.

  "handshake"
  my $handshake = $ws->handshake;
  $ws           = $ws->handshake(Mojo::Transaction::HTTP->new);

The original handshake transaction, defaults to a Mojo::Transaction::HTTP object.

  "masked"
  my $masked = $ws->masked;
  $ws        = $ws->masked(1);

Mask outgoing frames with XOR cipher and a random 32bit key.

  "max_websocket_size"
  my $size = $ws->max_websocket_size;
  $ws      = $ws->max_websocket_size(1024);

Maximum WebSocket message size in bytes, defaults to the value of the "MOJO_MAX_WEBSOCKET_SIZE" environment variable or 262144.

METHODS
Mojo::Transaction::WebSocket inherits all methods from Mojo::Transaction and implements the following new ones.

  "build_frame"
  my $bytes = $ws->build_frame($fin, $rsv1, $rsv2, $rsv3, $op, $payload);

Build WebSocket frame.

  # Build single "Binary" frame
  say $ws->build_frame(1, 0, 0, 0, 2, 'Hello World!');

  "client_challenge"
  my $success = $ws->client_challenge;

Check WebSocket handshake challenge.

  "client_handshake"
  $ws->client_handshake;

WebSocket handshake.

  "client_read"
  $ws->client_read($data);

Read raw WebSocket data.

  "client_write"
  my $chunk = $ws->client_write;

Raw WebSocket data to write.

  "connection"
  my $connection = $ws->connection;

Alias for "connection" in Mojo::Transaction.

  "finish"
  $ws = $ws->finish;

Finish the WebSocket connection gracefully.

  "is_websocket"
  my $true = $ws->is_websocket;

True.

  "kept_alive"
  my $kept_alive = $ws->kept_alive;

Alias for "kept_alive" in Mojo::Transaction.

  "local_address"
  my $local_address = $ws->local_address;

Alias for "local_address" in Mojo::Transaction.

  "local_port"
  my $local_port = $ws->local_port;

Alias for "local_port" in Mojo::Transaction.

  "parse_frame"
  my $frame = $ws->parse_frame(\$bytes);

Parse WebSocket frame.

  # Parse single frame and remove it from buffer
  my $frame = $ws->parse_frame(\$buffer);
  say "Fin: $frame->[0]";
  say "Rsv1: $frame->[1]";
  say "Rsv2: $frame->[2]";
  say "Rsv3: $frame->[3]";
  say "Op: $frame->[4]";
  say "Payload: $frame->[5]";

  "remote_address"
  my $remote_address = $ws->remote_address;

Alias for "remote_address" in Mojo::Transaction.

  "remote_port"
  my $remote_port = $ws->remote_port;

Alias for "remote_port" in Mojo::Transaction.

  "req"
  my $req = $ws->req;

Alias for "req" in Mojo::Transaction.

  "res"
  my $res = $ws->res;

Alias for "res" in Mojo::Transaction.

  "resume"
  $ws = $ws->resume;

Alias for "resume" in Mojo::Transaction.

  "send"
  $ws->send({binary => $bytes});
  $ws->send({text   => $bytes});
  $ws->send([$fin, $rsv1, $rsv2, $rsv3, $op, $payload]);
  $ws->send('Hi there!');
  $ws->send('Hi there!' => sub {...});

Send message or frame non-blocking via WebSocket, the optional drain callback will be invoked once all data has been written.

  # Send "Ping" frame
  $ws->send([1, 0, 0, 0, 9, 'Hello World!']);

  "server_handshake"
  $ws->server_handshake;

WebSocket handshake.

  "server_read"
  $ws->server_read($data);

Read raw WebSocket data.

  "server_write"
  my $chunk = $ws->server_write;

Raw WebSocket data to write.

DEBUGGING
You can set the "MOJO_WEBSOCKET_DEBUG" environment variable to get some advanced diagnostics information printed to "STDERR".

  MOJO_WEBSOCKET_DEBUG=1

SEE ALSO
Mojolicious, Mojolicious::Guides, <http://mojolicio.us>.