Mojo::Transaction::WebSocket(3pm)			User Contributed Perl Documentation			 Mojo::Transaction::WebSocket(3pm)

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. Note that 64bit frames require a Perl with
       64bit integer support, or they are limited to 32bit.

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->unsubscribe('frame');
	 $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]";
	 });

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

   "new"
	 my $multi = Mojo::Content::MultiPart->new;

       Construct a new Mojo::Transaction::WebSocket object and subscribe to "frame" event with default message parser, which also handles "PING"
       and "CLOSE" frames automatically.

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

       Build WebSocket frame.

	 # Continuation frame with FIN bit and payload
	 say $ws->build_frame(1, 0, 0, 0, 0, 'World!');

	 # Text frame with payload
	 say $ws->build_frame(0, 0, 0, 0, 1, 'Hello');

	 # Binary frame with FIN bit and payload
	 say $ws->build_frame(1, 0, 0, 0, 2, 'Hello World!');

	 # Close frame with FIN bit and without payload
	 say $ws->build_frame(1, 0, 0, 0, 8, '');

	 # Ping frame with FIN bit and payload
	 say $ws->build_frame(1, 0, 0, 0, 9, 'Test 123');

	 # Pong frame with FIN bit and payload
	 say $ws->build_frame(1, 0, 0, 0, 10, 'Test 123');

   "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 "Opcode: $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>.

perl v5.14.2							    2012-09-05					 Mojo::Transaction::WebSocket(3pm)