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  -  POCKETIO (3)

.ds Aq ’

NAME

PocketIO - Socket.IO PSGI application

CONTENTS

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.

TLS/SSL

For TLS/SSL a secure proxy is needed. stunnel or App::TLSMe are recommended.

SCALING

See PocketIO::Pool::Redis.

DEBUGGING

Use POCKETIO_DEBUG and POCKETIO_CONNECTION_DEBUG variables for debugging.

METHODS

CWnew

Create a new PocketIO instance.

CWpool

Holds PocketIO::Pool object by default.

CWcall

For Plack apps compatibility.

CWto_app

Returns PSGI code reference.

SEE ALSO

More information about SocketIO you can find on the website <http://socket.io/>, or on the GitHub <https://github.com/LearnBoost/Socket.IO>.

Protocol::SocketIO, PSGI

DEVELOPMENT

    Repository



    http://github.com/vti/pocketio



CREDITS

Socket.IO author(s) and contributors.

Jens Gassmann

Uwe Voelker

Oskari Okko Ojala

Jason May

Michael FiG

Peter Stuifzand

tokubass

mvgrimes

AUTHOR

Viacheslav Tykhanovskyi, vti@cpan.org.

COPYRIGHT AND LICENSE

Copyright (C) 2011-2013, Viacheslav Tykhanovskyi

This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version 2.0.

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


perl v5.20.3 POCKETIO (3) 2016-04-03

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