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 ($ws, $msg) { say
"Message: $msg" });
$ws−>on(finish => sub ($ws, $code, $reason) {
say "WebSocket closed with status $code." });
Mojo::Transaction::WebSocket is a container for WebSocket transactions, based on RFC 6455 <https://tools.ietf.org/html/rfc6455> and RFC 7692 <https://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 ($ws, $bytes) {...});
Emitted when a complete WebSocket binary message has been received.
$ws−>on(binary => sub ($ws, $bytes) { say "Binary: $bytes" });
$ws−>on(drain => sub ($ws) {...});
Emitted once all data has been sent.
$ws−>on(drain => sub ($ws) { $ws−>send(time) });
$ws−>on(finish => sub ($ws, $code, $reason) {...});
Emitted when the WebSocket connection has been closed.
$ws−>on(frame => sub ($ws, $frame) {...});
Emitted when a WebSocket frame has been received.
$ws−>on(frame
=> sub ($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 ($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 ($ws, $hash) { say "Message: $hash−>{msg}" });
$ws−>on(message => sub ($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 ($ws, $msg) { say "Message: $msg" });
$tx−>on(resume => sub ($tx) {...});
Emitted when transaction is resumed.
$ws−>on(text => sub ($ws, $bytes) {...});
Emitted when a complete WebSocket text message has been received.
$ws−>on(text => sub ($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 qw(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>.