GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages
Mojo::Transaction::WebSocket(3) User Contributed Perl Documentation Mojo::Transaction::WebSocket(3)
 

Mojo::Transaction::WebSocket - WebSocket transaction

  use Mojo::Transaction::WebSocket;
  # Send and receive WebSocket messages
  my $ws = Mojo::Transaction::WebSocket->new;
  $ws->send('Hello World!');
  $ws->on(message => sub {
    my ($ws, $msg) = @_;
    say "Message: $msg";
  });
  $ws->on(finish => sub {
    my ($ws, $code, $reason) = @_;
    say "WebSocket closed with status $code.";
  });

Mojo::Transaction::WebSocket is a container for WebSocket transactions, based on RFC 6455 <http://tools.ietf.org/html/rfc6455> and RFC 7692 <http://tools.ietf.org/html/rfc7692>.

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

  $ws->on(binary => sub {
    my ($ws, $bytes) = @_;
    ...
  });
Emitted when a complete WebSocket binary message has been received.
  $ws->on(binary => sub {
    my ($ws, $bytes) = @_;
    say "Binary: $bytes";
  });

  $ws->on(drain => sub {
    my $ws = shift;
    ...
  });
Emitted once all data has been sent.
  $ws->on(drain => sub {
    my $ws = shift;
    $ws->send(time);
  });

  $ws->on(finish => sub {
    my ($ws, $code, $reason) = @_;
    ...
  });
Emitted when the WebSocket connection has been closed.

  $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 "Opcode: $frame->[4]";
    say "Payload: $frame->[5]";
  });

  $ws->on(json => sub {
    my ($ws, $json) = @_;
    ...
  });
Emitted when a complete WebSocket message has been received, all text and binary messages will be automatically JSON decoded. Note that this event only gets emitted when it has at least one subscriber.
  $ws->on(json => sub {
    my ($ws, $hash) = @_;
    say "Message: $hash->{msg}";
  });

  $ws->on(message => sub {
    my ($ws, $msg) = @_;
    ...
  });
Emitted when a complete WebSocket message has been received, text messages will be automatically decoded. Note that this event only gets emitted when it has at least one subscriber.
  $ws->on(message => sub {
    my ($ws, $msg) = @_;
    say "Message: $msg";
  });

  $tx->on(resume => sub {
    my $tx = shift;
    ...
  });
Emitted when transaction is resumed.

  $ws->on(text => sub {
    my ($ws, $bytes) = @_;
    ...
  });
Emitted when a complete WebSocket text message has been received.
  $ws->on(text => sub {
    my ($ws, $bytes) = @_;
    say "Text: $bytes";
  });

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

  my $bool = $ws->compressed;
  $ws      = $ws->compressed($bool);
Compress messages with "permessage-deflate" extension.

  my $bool = $ws->established;
  $ws      = $ws->established($bool);
WebSocket connection established.

  my $handshake = $ws->handshake;
  $ws           = $ws->handshake(Mojo::Transaction::HTTP->new);
The original handshake transaction, usually a Mojo::Transaction::HTTP object.

  my $bool = $ws->masked;
  $ws      = $ws->masked($bool);
Mask outgoing frames with XOR cipher and a random 32-bit key.

  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 (256KiB).

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

  my $frame = $ws->build_message({binary => $bytes});
  my $frame = $ws->build_message({text   => $bytes});
  my $frame = $ws->build_message({json   => {test => [1, 2, 3]}});
  my $frame = $ws->build_message($chars);
Build WebSocket message.

  $ws->client_read($data);
Read data client-side, used to implement user agents such as Mojo::UserAgent.

  my $bytes = $ws->client_write;
Write data client-side, used to implement user agents such as Mojo::UserAgent.

  $tx = $tx->closed;
Same as "completed" in Mojo::Transaction, but also indicates that all transaction data has been sent.

  my $id = $ws->connection;
Connection identifier.

  $ws = $ws->finish;
  $ws = $ws->finish(1000);
  $ws = $ws->finish(1003 => 'Cannot accept data!');
Close WebSocket connection gracefully.

  my $bool = $ws->is_websocket;
True, this is a Mojo::Transaction::WebSocket object.

  my $bool = $ws->kept_alive;
Connection has been kept alive.

  my $address = $ws->local_address;
Local interface address.

  my $port = $ws->local_port;
Local interface port.

  $ws->parse_message([$fin, $rsv1, $rsv2, $rsv3, $op, $payload]);
Parse WebSocket message.

  my $proto = $ws->protocol;
Return negotiated subprotocol or "undef".

  my $address = $ws->remote_address;
Remote interface address.

  my $port = $ws->remote_port;
Remote interface port.

  my $req = $ws->req;
Handshake request, usually a Mojo::Message::Request object.

  my $res = $ws->res;
Handshake response, usually a Mojo::Message::Response object.

  $ws = $ws->resume;
Resume "handshake" transaction.

  $ws = $ws->send({binary => $bytes});
  $ws = $ws->send({text   => $bytes});
  $ws = $ws->send({json   => {test => [1, 2, 3]}});
  $ws = $ws->send([$fin, $rsv1, $rsv2, $rsv3, $op, $payload]);
  $ws = $ws->send($chars);
  $ws = $ws->send($chars => sub {...});
Send message or frame non-blocking via WebSocket, the optional drain callback will be executed once all data has been written.
  # Send "Ping" frame
  use Mojo::WebSocket 'WS_PING';
  $ws->send([1, 0, 0, 0, WS_PING, 'Hello World!']);

  $ws->server_read($data);
Read data server-side, used to implement web servers such as Mojo::Server::Daemon.

  my $bytes = $ws->server_write;
Write data server-side, used to implement web servers such as Mojo::Server::Daemon.

  $ws->with_compression;
Negotiate "permessage-deflate" extension for this WebSocket connection.

  my $proto = $ws->with_protocols('v2.proto', 'v1.proto');
Negotiate subprotocol for this WebSocket connection.

Mojolicious, Mojolicious::Guides, <https://mojolicious.org>.
2018-11-28 perl v5.28.1

Search for    or go to Top of page |  Section 3 |  Main Index

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with ManDoc.