NAME

PocketIO - Socket.IO PSGI application

SYNOPSIS

use Plack::Builder;

builder {
    mount '/socket.io' => PocketIO->new(
        handler => sub {
            my $self = shift;

            $self->on(
                'message' => sub {
                    my $self = shift;
                    my ($message) = @_;

                    ...;
                }
            );

            $self->send({buffer => []});
        }
    );

    $app;
};

# or

builder {
    mount '/socket.io' =>
      PocketIO->new(class => 'MyApp::Handler', method => 'run');

    $app;
};

DESCRIPTION

PocketIO is a server implementation of SocketIO in Perl, you still need socket.io javascript library on the client.

PocketIO aims to have API as close as possible to the Node.js implementation and sometimes it might look not very perlish.

How to use

First you mount PocketIO as a normal Plack application. It is recommended to mount it to the /socket.io path since that will not require any changes on the client side.

When the client is connected your handler is called with a PocketIO::Socket object as a first parameter.

Sending and receiving messages

A simple echo handler can look like this:

sub {
    my $self = shift;

    $self->on('message' => sub {
        my $self = shift;
        my ($message) = @_;

        $self->send($message);
    });
}

Sending and receiving events

Events are special messages that behave like rpc calls.

sub {
    my $self = shift;

    $self->on('username' => sub {
        my $self = shift;
        my ($nick) = @_;

        ...
    });

    $self->emit('username', 'vti');
}

Broadcasting and sending messages/events to everybody

Broadcasting is sending messages to everybody except you:

$self->broadcast->send('foo');
$self->broadcast->emit('foo');

Method sockets represents all connected clients:

$self->sockets->send('foo');
$self->sockets->emit('foo');

Acknowlegements

Sometimes you want to know when the client received a message or event. In order to achieve this just pass a callback as the last parameter:

$self->send('foo', sub {'client got message'});
$self->emit('foo', sub {'client got event'});

Storing data in the socket object

Often it is required to store some data in the client object. Instead of using global variables there are two handy methods:

sub {
    my $self = shift;

    $self->set(foo => 'bar', sub { 'ready' });
    $self->get('foo' => sub {
        my $self = shift;
        my ($err, $foo) = @_;
    });
}

Namespacing

Not implemented yet.

Volatile messages

Not implemented yet.

Rooms

A room is a named group of connections for more fine-grained broadcasts. You can subscribe or unsubscribe a socket to/from a room:

sub {
    my $self = shift;

    $self->join('a room');

    $self->sockets->in('a room')->emit('message', data);
    $self->broadcast->to('a room')->emit("other message");
}

CONFIGURATIONS

handler

  PocketIO->new(
      handler => sub {
          my $socket = shift;

          $socket->on(
              'message' => sub {
                  my $socket = shift;
              }
          );

          $socket->send('hello');
      }
  );

class or instance, method

  PocketIO->new(class => 'MyHandler', method => 'run');

  # or

  PocketIO->new(instance => MyHandler->new(foo => 'bar'), method => 'run');

  package MyHandler;

  sub new { ...  } # or use Moose, Boose, Goose, Doose

  sub run {
      my $self = shift;

      return sub {

          # same code as above
      }
  }

Loads class, creates a new object or uses a passed instance and runs run method expecting it to return an anonymous subroutine.