slangerq 0.6.1

data/lib/slanger/presence_subscription.rb

@@ -0,0 +1,33 @@
+module Slanger
+  class PresenceSubscription < Subscription
+    def subscribe
+      return handle_invalid_signature if invalid_signature?
+
+      unless channel_data?
+        return connection.error({
+          message: "presence-channel is a presence channel and subscription must include channel_data"
+        })
+      end
+
+      channel.subscribe(@msg, callback) { |m| send_message m }
+    end
+
+    private
+
+    def channel_data?
+      @msg['data']['channel_data']
+    end
+
+    def callback
+      Proc.new {
+        connection.send_payload(channel_id, 'pusher_internal:subscription_succeeded', {
+          presence: {
+            count: channel.subscribers.size,
+            ids:   channel.ids,
+            hash:  channel.subscribers
+          }
+        })
+      }
+    end
+  end
+end

data/lib/slanger/private_subscription.rb

@@ -0,0 +1,9 @@
+module Slanger
+  class PrivateSubscription < Subscription
+    def subscribe
+      return handle_invalid_signature if auth && invalid_signature?
+
+      Subscription.new(connection.socket, connection.socket_id, @msg).subscribe
+    end
+  end
+end

data/lib/slanger/redis.rb

@@ -0,0 +1,41 @@
+# Redis class.
+# Interface with Redis.
+
+require 'forwardable'
+require 'oj'
+
+module Slanger
+  module Redis
+    extend Forwardable
+
+    def_delegator  :publisher, :publish
+    def_delegators :subscriber, :subscribe
+    def_delegators :regular_connection, :hgetall, :hdel, :hset, :hincrby
+
+    private
+
+    def regular_connection
+      @regular_connection ||= new_connection
+    end
+
+    def publisher
+      @publisher ||= new_connection
+    end
+
+    def subscriber
+      @subscriber ||= new_connection.pubsub.tap do |c|
+        c.on(:message) do |channel, message|
+          message = Oj.load(message)
+          c = Channel.from message['channel']
+          c.dispatch message, channel
+        end
+      end
+    end
+
+    def new_connection
+      EM::Hiredis.connect Slanger::Config.redis_address
+    end
+
+    extend self
+  end
+end

data/lib/slanger/service.rb

@@ -0,0 +1,20 @@
+require 'thin'
+require 'rack'
+
+module Slanger
+  module Service
+    def run
+      Slanger::Config[:require].each { |f| require f }
+      Thin::Logging.silent = true
+      Rack::Handler::Thin.run Slanger::Api::Server, Host: Slanger::Config.api_host, Port: Slanger::Config.api_port
+      Slanger::WebSocketServer.run
+    end
+
+    def stop
+      EM.stop if EM.reactor_running?
+    end
+
+    extend self
+    Signal.trap('HUP') { Slanger::Service.stop }
+  end
+end

data/lib/slanger/subscription.rb

@@ -0,0 +1,53 @@
+module Slanger
+  class Subscription
+    attr_accessor :connection, :socket
+    delegate :send_payload, :send_message, :error, :socket_id, to: :connection
+
+    def initialize socket, socket_id, msg
+      @connection = Connection.new socket, socket_id
+      @msg        = msg
+    end
+
+    def subscribe
+      send_payload channel_id, 'pusher_internal:subscription_succeeded'
+
+      channel.subscribe { |m| send_message m }
+    end
+
+    private
+
+    def channel
+      Channel.from channel_id
+    end
+
+    def channel_id
+      @msg['data']['channel']
+    end
+
+    def token(channel_id, params=nil)
+      to_sign = [socket_id, channel_id, params].compact.join ':'
+
+      digest = OpenSSL::Digest::SHA256.new
+      OpenSSL::HMAC.hexdigest digest, Slanger::Config.secret, to_sign
+    end
+
+    def invalid_signature?
+      token(channel_id, data) != auth.split(':')[1]
+    end
+
+    def auth
+      @msg['data']['auth']
+    end
+
+    def data
+      @msg['data']['channel_data']
+    end
+
+    def handle_invalid_signature
+      message = "Invalid signature: Expected HMAC SHA256 hex digest of "
+      message << "#{socket_id}:#{channel_id}, but got #{auth}"
+
+      error({ message: message})
+    end
+  end
+end

data/lib/slanger/version.rb

@@ -0,0 +1,3 @@
+module Slanger
+  VERSION = '0.6.1'
+end

data/lib/slanger/web_socket_server.rb

@@ -0,0 +1,37 @@
+require 'eventmachine'
+require 'em-websocket'
+
+module Slanger
+  module WebSocketServer
+    def run
+      case
+      when EM.epoll?  then EM.epoll
+      when EM.kqueue? then EM.kqueue
+      end
+
+      EM.run do
+        options = {
+          host:    Slanger::Config[:websocket_host],
+          port:    Slanger::Config[:websocket_port],
+          debug:   Slanger::Config[:debug],
+          app_key: Slanger::Config[:app_key]
+        }
+
+        if Slanger::Config[:tls_options]
+          options.merge! secure: true,
+                         tls_options: Slanger::Config[:tls_options]
+        end
+
+        EM::WebSocket.start options do |ws|
+          # Keep track of handler instance in instance of EM::Connection to ensure a unique handler instance is used per connection.
+          ws.class_eval    { attr_accessor :connection_handler }
+          # Delegate connection management to handler instance.
+          ws.onopen        { |handshake| ws.connection_handler = Slanger::Config.socket_handler.new ws, handshake }
+          ws.onmessage     { |msg| ws.connection_handler.onmessage msg }
+          ws.onclose       { ws.connection_handler.onclose }
+        end
+      end
+    end
+    extend self
+  end
+end

data/lib/slanger/webhook.rb

@@ -0,0 +1,31 @@
+require 'fiber'
+require 'em-http-request'
+require 'oj'
+
+module Slanger
+  module Webhook
+    def post payload
+      return unless Slanger::Config.webhook_url
+
+      payload ={
+        time_ms: Time.now.strftime('%s%L'), events: [payload]
+      }
+
+      payload = Oj.dump(payload, mode: :compat)
+
+      digest        = OpenSSL::Digest::SHA256.new
+      hmac          = OpenSSL::HMAC.hexdigest(digest, Slanger::Config.secret, payload)
+      content_type  = 'application/json'
+
+      EM::HttpRequest.new(Slanger::Config.webhook_url).
+        post(body: payload, head: { 
+          "X-Pusher-Key" => Slanger::Config.app_key, 
+          "X-Pusher-Signature" => hmac, 
+          "Content-Type" => content_type 
+        })
+        # TODO: Exponentially backed off retries for errors
+    end
+
+    extend self
+  end
+end

data/slanger.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require 'eventmachine'
+require 'em-hiredis'
+require 'rack'
+require 'active_support/core_ext/string'
+require File.join(File.dirname(__FILE__), 'lib', 'slanger', 'version')
+
+module Slanger; end
+
+case
+when EM.epoll?  then EM.epoll
+when EM.kqueue? then EM.kqueue
+end
+
+File.tap do |f|
+  Dir[f.expand_path(f.join(f.dirname(__FILE__),'lib', 'slanger', '*.rb'))].each do |file|
+    Slanger.autoload File.basename(file, '.rb').camelize, file
+  end
+
+  Dir[f.expand_path(f.join(f.dirname(__FILE__),'lib', 'slanger', 'api', '*.rb'))].each do |file|
+    Slanger::Api.autoload File.basename(file, '.rb').camelize, file
+  end
+end

data/spec/have_attributes.rb

@@ -0,0 +1,64 @@
+module SlangerHelperMethods
+  class HaveAttributes
+    attr_reader :messages, :attributes
+    def initialize attributes
+      @attributes = attributes
+    end
+
+    CHECKS = %w(first_event last_event last_data )
+
+    def matches?(messages)
+      @messages = messages
+      @failures = []
+
+      check_connection_established if attributes[:connection_established]
+      check_id_present             if attributes[:id_present]
+
+      CHECKS.each { |a| attributes[a.to_sym] ?  check(a) : true }
+
+      @failures.empty?
+    end
+
+    def check message
+      send(message) == attributes[message.to_sym] or @failures << message
+    end
+
+    def failure_message
+      @failures.map {|f| "expected #{f}: to equal #{attributes[f]} but got #{send(f)}"}.join "\n"
+    end
+
+    private
+
+    def check_connection_established
+      if first_event != 'pusher:connection_established'
+        @failures << :connection_established
+      end
+    end
+
+    def check_id_present
+      if messages.first['data']['socket_id'] == nil
+        @failures << :id_present
+      end
+    end
+
+    def first_event
+      messages.first['event']
+    end
+
+    def last_event
+      messages.last['event']
+    end
+
+    def last_data
+      messages.last['data']
+    end
+
+    def count
+      messages.length
+    end
+  end
+
+  def have_attributes attributes
+    HaveAttributes.new attributes
+  end
+end

data/spec/integration/channel_spec.rb

@@ -0,0 +1,114 @@
+#encoding: utf-8
+require 'spec_helper'
+
+describe 'Integration:' do
+
+  before(:each) { start_slanger }
+
+  describe 'channel' do
+    it 'pushes messages to interested websocket connections' do
+      messages = em_stream do |websocket, messages|
+        case messages.length
+        when 1
+          websocket.callback { websocket.send({ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }.to_json) }
+        when 2
+          Pusher['MY_CHANNEL'].trigger 'an_event', some: "Mit Raben Und Wölfen"
+        when 3
+          EM.stop
+        end
+     end
+
+      expect(messages).to have_attributes connection_established: true, id_present: true,
+        last_event: 'an_event', last_data: { some: "Mit Raben Und Wölfen" }.to_json
+    end
+
+    it 'does not send message to excluded sockets' do
+      messages = em_stream do |websocket, messages|
+        case messages.length
+        when 1
+          websocket.callback { websocket.send({ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }.to_json) }
+        when 2
+          socket_id = JSON.parse(messages.first["data"])["socket_id"]
+          Pusher['MY_CHANNEL'].trigger 'not_excluded_socket_event', { some: "Mit Raben Und Wölfen" }
+          Pusher['MY_CHANNEL'].trigger 'excluded_socket_event', { some: "Mit Raben Und Wölfen" }, socket_id
+        when 3
+          EM.stop
+        end
+     end
+
+      expect(messages).to have_attributes connection_established: true, id_present: true,
+        last_event: 'not_excluded_socket_event', last_data: { some: "Mit Raben Und Wölfen" }.to_json
+    end
+
+    it 'enforces one subcription per channel, per socket' do
+      messages = em_stream do |websocket, messages|
+        case messages.length
+        when 1
+          websocket.callback { websocket.send({ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }.to_json) }
+        when 2
+          websocket.send({ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }.to_json)
+        when 3
+          EM.stop
+        end
+     end
+
+      expect(messages.last).to eq({"event"=>"pusher:error", "data"=>"{\"code\":null,\"message\":\"Existing subscription to MY_CHANNEL\"}"})
+    end
+
+    it 'supports unsubscribing to channels without closing the socket' do
+      client2_messages = nil
+
+      messages = em_stream do |client, messages|
+        case messages.length
+        when 1
+          client.callback { client.send({ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }.to_json) }
+        when 2
+          client.send({ event: 'pusher:unsubscribe', data: { channel: 'MY_CHANNEL'} }.to_json)
+
+          client2_messages = em_stream do |client2, client2_messages|
+            case client2_messages.length
+              when 1
+                client2.callback { client2.send({ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }.to_json) }
+              when 2
+                Pusher['MY_CHANNEL'].trigger 'an_event', { some: 'data' }
+                EM.next_tick { EM.stop }
+            end
+          end
+        end
+      end
+
+      expect(messages).to have_attributes connection_established: true, id_present: true,
+        last_event: 'pusher_internal:subscription_succeeded', count: 2
+    end
+
+    it 'avoids sending duplicate events' do
+      client2_messages = nil
+
+      client1_messages = em_stream do |client1, client1_messages|
+        # if this is the first message to client 1 set up another connection from the same client
+        if client1_messages.one?
+          client1.callback do
+            client1.send({ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }.to_json)
+          end
+
+          client2_messages = em_stream do |client2, client2_messages|
+            case client2_messages.length
+            when 1
+              client2.callback { client2.send({ event: 'pusher:subscribe', data: { channel: 'MY_CHANNEL'} }.to_json) }
+            when 2
+              socket_id = JSON.parse(client1_messages.first['data'])['socket_id']
+              Pusher['MY_CHANNEL'].trigger 'an_event', { some: 'data' }, socket_id
+            when 3
+              EM.stop
+            end
+          end
+        end
+      end
+
+      expect(client1_messages).to have_attributes count: 2
+
+      expect(client2_messages).to have_attributes last_event: 'an_event',
+                                                  last_data: { some: 'data' }.to_json
+    end
+  end
+end