File Coverage

blib/lib/WWW/Pusher/Client.pm

Criterion	Covered	Total	%
statement	41	54	75.9
branch	3	8	37.5
condition	1	5	20.0
subroutine	13	16	81.2
pod	2	3	66.6
total	60	86	69.7

package WWW::Pusher::Client;
# ABSTRACT: Laughably incomplete Perl client for Pusher WS API
$WWW::Pusher::Client::VERSION = '0.04';
use strict;
use warnings;
use 5.010_001;
use Moo;
use JSON;
use Carp;
use AnyEvent::WebSocket::Client;
use Digest::SHA qw(hmac_sha256_hex);


has 'auth_key' => (
    is => 'ro' ,
    required => 1
);

has 'secret' => (
    is => 'ro',
    required => 1
);

has 'channel' => (
    is => 'rw',
    coerce => sub {
        my ($channel) = @_;

        if ($channel =~ /^[A-Za-z0-9_\-=@,.;]+$/) {
            return $channel;
        }
        else {
            croak 'channel is invalid';
        }
    },
    predicate => 'has_channel'
);

has 'client' => (
    is => 'ro',
    lazy => 1,
    default => sub { AnyEvent::WebSocket::Client->new }
);

has 'ws_url' => (
    is => 'ro',
    lazy => 1,
    builder => sub {
        my $self = shift;

        return $self->_scheme . $self->_pusher_base . $self->_port
          . "/app/" . $self->auth_key
          . "?protocol=" . $self->_protocol
          . "&client=" . $self->_client_name
          . "&version=" . $self->_version
    }
);

has 'ws_conn' => (
    is => 'ro',
    lazy => 1,
    builder => sub {
        my $self = shift;

        # open the connection and immediately ->recv the condvar to
        # return control back to us
        return $self->client->connect($self->ws_url)->recv;
    }
);

has '_scheme' => (
    is => 'ro',
    default => sub { 'ws' }
);

has '_port' => (
    is => 'ro',
    default => sub { 80 }
);

has '_pusher_base' => (
    is => 'ro',
    default => sub { '://ws.pusherapp.com:' }
);

has '_protocol' => (
    is => 'ro',
    default => sub { 7 }
);

has '_client_name' => (
    is => 'ro',
    default => sub { 'perl-pusher-client' }
);

has '_version' => (
    is => 'ro',
    default => sub { '0.001' }
);

has '_socket_id' => (
    is => 'rw',
    coerce => sub {
        my ($socket_id) = @_;

        if ($socket_id =~ /^\d+\.\d+$/) {
            return $socket_id;
        }
        else {
            croak 'socket_id is invalid';
        }
    }
);


sub BUILD {
    my $self = shift;

    $self->ws_conn->on(
        next_message => sub {
            my ($conn, $message) = @_;
            my $body = from_json($message->decoded_body);

            if ($body->{event} eq 'pusher:connection_established') {
                $self->_socket_id(from_json($body->{data})->{socket_id});

                $self->subscribe($self->channel) if $self->has_channel;
            }
            else {
                die 'Connection error?' . $message->decoded_body;
            }
        });
}


sub subscribe {
    my ($self, $channel) = @_;

    my $data = $self->_construct_private_auth_data($channel);

    return $self->ws_conn->send(to_json({
        event => 'pusher:subscribe',
        data => $data
    }));
}

sub _construct_private_auth_data {
    my ($self, $channel) = @_;
    $channel //= $self->channel;

    # Public channels only need the channel name in the payload
    my $data = { channel => $channel };

    # Private channels need a key:signature in the auth key for
    # authorization
    if ($channel =~ /^private-/) {
        my $signature = $self->_socket_auth($channel);
        $data->{auth} = $self->auth_key . ':' . $signature;
    }

    return $data;
}

sub _socket_auth {
    my ($self, $channel) = @_;
    die 'Missing socket_id, sorry...' unless $self->_socket_id;

    my $plainSignature = $self->_socket_id . ':' . $channel;
    return hmac_sha256_hex($plainSignature, $self->secret);
}


sub trigger {
    my $self = shift;
    my $event = shift // 'ws update';
    my $message = shift;

    $self->ws_conn->send(to_json({
        event => $event,
        channel => $self->channel,
        data => $message
    }));
}


1;

__END__