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


Manual Reference Pages  -  MOJO::TRANSACTION::WEBSOCKET (3)

.ds Aq ’

NAME

Mojo::Transaction::WebSocket - WebSocket transaction

CONTENTS

SYNOPSIS



  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.";
  });



DESCRIPTION

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>.

EVENTS

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

    binary



  $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";
  });



    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);
  });



    finish



  $ws->on(finish => sub {
    my ($ws, $code, $reason) = @_;
    ...
  });



Emitted when the WebSocket connection has been closed.

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



    json



  $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}";
  });



    message



  $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";
  });



    resume



  $tx->on(resume => sub {
    my $tx = shift;
    ...
  });



Emitted when transaction is resumed.

    text



  $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";
  });



ATTRIBUTES

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

    compressed



  my $bool = $ws->compressed;
  $ws      = $ws->compressed($bool);



Compress messages with permessage-deflate extension.

    established



  my $bool = $ws->established;
  $ws      = $ws->established($bool);



WebSocket connection established.

    handshake



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



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

    masked



  my $bool = $ws->masked;
  $ws      = $ws->masked($bool);



Mask outgoing frames with XOR cipher and a random 32-bit 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 (256KB).

METHODS

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

    build_message



  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.

    client_read



  $ws->client_read($data);



Read data client-side, used to implement user agents such as Mojo::UserAgent.

    client_write



  my $bytes = $ws->client_write;



Write data client-side, used to implement user agents such as Mojo::UserAgent.

    closed



  $tx = $tx->closed;



Same as completed in Mojo::Transaction, but also indicates that all transaction data has been sent.

    connection



  my $id = $ws->connection;



Connection identifier.

    finish



  $ws = $ws->finish;
  $ws = $ws->finish(1000);
  $ws = $ws->finish(1003 => Cannot accept data!);



Close WebSocket connection gracefully.

    is_websocket



  my $bool = $ws->is_websocket;



True, this is a Mojo::Transaction::WebSocket object.

    kept_alive



  my $bool = $ws->kept_alive;



Connection has been kept alive.

    local_address



  my $address = $ws->local_address;



Local interface address.

    local_port



  my $port = $ws->local_port;



Local interface port.

    parse_message



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



Parse WebSocket message.

    protocol



  my $proto = $ws->protocol;



Return negotiated subprotocol or undef.

    remote_address



  my $address = $ws->remote_address;



Remote interface address.

    remote_port



  my $port = $ws->remote_port;



Remote interface port.

    req



  my $req = $ws->req;



Handshake request, usually a Mojo::Message::Request object.

    res



  my $res = $ws->res;



Handshake response, usually a Mojo::Message::Response object.

    resume



  $ws = $ws->resume;



Resume handshake transaction.

    send



  $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!]);



    server_read



  $ws->server_read($data);



Read data server-side, used to implement web servers such as Mojo::Server::Daemon.

    server_write



  my $bytes = $ws->server_write;



Write data server-side, used to implement web servers such as Mojo::Server::Daemon.

    with_compression



  $ws->with_compression;



Negotiate permessage-deflate extension for this WebSocket connection.

    with_protocols



  my $proto = $ws->with_protocols(v2.proto, v1.proto);



Negotiate subprotocol for this WebSocket connection.

SEE ALSO

Mojolicious, Mojolicious::Guides, <http://mojolicious.org>.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 MOJO::TRANSACTION::WEBSOCKET (3) 2016-03-15

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