kalebr-pusher 0.6.1

data/lib/slanger/config.rb

@@ -0,0 +1,27 @@
+# Config singleton holding the configuration.
+
+module Slanger
+  module Config
+    def load(opts={})
+      options.update opts
+    end
+
+    def [](key)
+      options[key]
+    end
+
+    def options
+      @options ||= {
+        api_host: '0.0.0.0', api_port: '4567', websocket_host: '0.0.0.0',
+        websocket_port: '8080', debug: false, redis_address: 'redis://0.0.0.0:6379/0',
+        socket_handler: Slanger::Handler, require: [], activity_timeout: 120
+      }
+    end
+
+    def method_missing(meth, *args, &blk)
+      options[meth]
+    end
+
+    extend self
+  end
+end

data/lib/slanger/connection.rb

@@ -0,0 +1,46 @@
+require 'oj'
+
+module Slanger
+  class Connection
+    attr_accessor :socket, :socket_id
+
+    def initialize socket, socket_id=nil
+      @socket, @socket_id = socket, socket_id
+    end
+
+    def send_message m
+      msg = Oj.load m
+      s = msg.delete 'socket_id'
+      socket.send Oj.dump(msg, mode: :compat) unless s == socket_id
+    end
+
+    def send_payload *args
+      socket.send format(*args)
+    end
+
+    def error e
+      begin
+        send_payload nil, 'pusher:error', e
+      rescue EventMachine::WebSocket::WebSocketError
+        # Raised if connecection already closed. Only seen with Thor load testing tool
+      end
+    end
+
+    def establish
+      @socket_id = "%d.%d" % [Process.pid, SecureRandom.random_number(10 ** 6)]
+
+      send_payload nil, 'pusher:connection_established', {
+        socket_id: @socket_id,
+        activity_timeout: Slanger::Config.activity_timeout
+      }
+    end
+
+    private
+
+    def format(channel_id, event_name, payload = {})
+      body = { event: event_name, data: Oj.dump(payload, mode: :compat) }
+      body[:channel] = channel_id if channel_id
+      Oj.dump(body, mode: :compat)
+    end
+  end
+end

data/lib/slanger/handler.rb

@@ -0,0 +1,121 @@
+# Handler class.
+# Handles a client connected via a websocket connection.
+
+require 'active_support/core_ext/hash'
+require 'securerandom'
+require 'signature'
+require 'fiber'
+require 'rack'
+require 'oj'
+
+module Slanger
+  class Handler
+
+    attr_accessor :connection
+    delegate :error, :send_payload, to: :connection
+
+    def initialize(socket, handshake)
+      @socket        = socket
+      @handshake     = handshake
+      @connection    = Connection.new(@socket)
+      @subscriptions = {}
+      authenticate
+    end
+
+    # Dispatches message handling to method with same name as
+    # the event name
+    def onmessage(msg)
+      msg = Oj.load(msg)
+
+      msg['data'] = Oj.load(msg['data']) if msg['data'].is_a? String
+
+      event = msg['event'].gsub(/\Apusher:/, 'pusher_')
+
+      if event =~ /\Aclient-/
+        msg['socket_id'] = connection.socket_id
+        Channel.send_client_message msg
+      elsif respond_to? event, true
+        send event, msg
+      end
+
+    rescue JSON::ParserError
+      error({ code: 5001, message: "Invalid JSON" })
+    rescue Exception => e
+      error({ code: 500, message: "#{e.message}\n #{e.backtrace.join "\n"}" })
+    end
+
+    def onclose
+
+      subscriptions = @subscriptions.select { |k,v| k && v }
+      
+      subscriptions.each_key do |channel_id|
+        subscription_id = subscriptions[channel_id]
+        Channel.unsubscribe channel_id, subscription_id
+      end
+
+    end
+
+    def authenticate
+      if !valid_app_key? app_key
+        error({ code: 4001, message: "Could not find app by key #{app_key}" })
+        @socket.close_websocket
+      elsif !valid_protocol_version?
+        error({ code: 4007, message: "Unsupported protocol version" })
+        @socket.close_websocket
+      else
+        return connection.establish
+      end
+    end
+
+    def valid_protocol_version?
+      protocol_version.between?(3, 7)
+    end
+
+    def pusher_ping(msg)
+      send_payload nil, 'pusher:pong'
+    end
+
+    def pusher_pong msg; end
+
+    def pusher_subscribe(msg)
+      channel_id = msg['data']['channel']
+      klass      = subscription_klass channel_id
+
+      if @subscriptions[channel_id]
+        error({ code: nil, message: "Existing subscription to #{channel_id}" })
+      else
+        @subscriptions[channel_id] = klass.new(connection.socket, connection.socket_id, msg).subscribe
+      end
+    end
+
+    def pusher_unsubscribe(msg)
+      channel_id      = msg['data']['channel']
+      subscription_id = @subscriptions.delete(channel_id)
+
+      Channel.unsubscribe channel_id, subscription_id
+    end
+
+    private
+
+    def app_key
+      @handshake.path.split(/\W/)[2]
+    end
+
+    def protocol_version
+      @query_string ||= Rack::Utils.parse_nested_query(@handshake.query_string)
+      @query_string["protocol"].to_i || -1
+    end
+
+    def valid_app_key? app_key
+      Slanger::Config.app_key == app_key
+    end
+
+    def subscription_klass channel_id
+      klass = channel_id.match(/\A(private|presence)-/) do |match|
+        Slanger.const_get "#{match[1]}_subscription".classify
+      end
+
+      klass || Slanger::Subscription
+    end
+  end
+end

data/lib/slanger/logger.rb

@@ -0,0 +1,7 @@
+module Slanger
+  module Logger
+    def log(msg)
+    end
+    extend self
+  end
+end

data/lib/slanger/presence_channel.rb

@@ -0,0 +1,140 @@
+# PresenceChannel class.
+#
+# Uses an EventMachine channel to let handlers interact with the
+# Pusher channel. Relay events received from Redis into the
+# EM channel. Keeps data on the subscribers to send it to clients.
+#
+
+require 'eventmachine'
+require 'forwardable'
+require 'fiber'
+require 'oj'
+
+module Slanger
+  class PresenceChannel < Channel
+    def_delegators :channel, :push
+
+    # Send an event received from Redis to the EventMachine channel
+    def dispatch(message, channel)
+      if channel =~ /\Aslanger:/
+        # Messages received from the Redis channel slanger:*  carry info on
+        # subscriptions. Update our subscribers accordingly.
+        update_subscribers message
+      else
+        push Oj.dump(message, mode: :compat)
+      end
+    end
+
+    def initialize(attrs)
+      super
+      # Also subscribe the slanger daemon to a Redis channel used for events concerning subscriptions.
+      Slanger::Redis.subscribe 'slanger:connection_notification'
+    end
+
+    def subscribe(msg, callback, &blk)
+      channel_data = Oj.load msg['data']['channel_data']
+      public_subscription_id = SecureRandom.uuid
+
+      # Send event about the new subscription to the Redis slanger:connection_notification Channel.
+      publisher = publish_connection_notification subscription_id: public_subscription_id, online: true,
+        channel_data: channel_data, channel: channel_id
+
+      # Associate the subscription data to the public id in Redis.
+      roster_add public_subscription_id, channel_data
+
+      # fuuuuuuuuuccccccck!
+      publisher.callback do
+        EM.next_tick do
+          # The Subscription event has been sent to Redis successfully.
+          # Call the provided callback.
+          callback.call
+          # Add the subscription to our table.
+          internal_subscription_table[public_subscription_id] = channel.subscribe &blk
+        end
+      end
+
+      public_subscription_id
+    end
+
+    def ids
+      subscriptions.map { |_,v| v['user_id'] }
+    end
+
+    def subscribers
+      Hash[subscriptions.map { |_,v| [v['user_id'], v['user_info']] }]
+    end
+
+    def unsubscribe(public_subscription_id)
+      # Unsubcribe from EM::Channel
+      channel.unsubscribe(internal_subscription_table.delete(public_subscription_id)) # if internal_subscription_table[public_subscription_id]
+      # Remove subscription data from Redis
+      roster_remove public_subscription_id
+      # Notify all instances
+      publish_connection_notification subscription_id: public_subscription_id, online: false, channel: channel_id
+    end
+
+    private
+
+    def get_roster
+      # Read subscription infos from Redis.
+      Fiber.new do
+        f = Fiber.current
+        Slanger::Redis.hgetall(channel_id).
+          callback { |res| f.resume res }
+        Fiber.yield
+      end.resume
+    end
+
+    def roster_add(key, value)
+      # Add subscription info to Redis.
+      Slanger::Redis.hset(channel_id, key, value)
+    end
+
+    def roster_remove(key)
+      # Remove subscription info from Redis.
+      Slanger::Redis.hdel(channel_id, key)
+    end
+
+    def publish_connection_notification(payload, retry_count=0)
+      # Send a subscription notification to the global slanger:connection_notification
+      # channel.
+      Slanger::Redis.publish('slanger:connection_notification', Oj.dump(payload, mode: :compat)).
+        tap { |r| r.errback { publish_connection_notification payload, retry_count.succ unless retry_count == 5 } }
+    end
+
+    # This is the state of the presence channel across the system. kept in sync
+    # with redis pubsub
+    def subscriptions
+      @subscriptions ||= get_roster || {}
+    end
+
+    # This is used map public subscription ids to em channel subscription ids.
+    # em channel subscription ids are incremented integers, so they cannot
+    # be used as keys in distributed system because they will not be unique
+    def internal_subscription_table
+      @internal_subscription_table ||= {}
+    end
+
+    def update_subscribers(message)
+      if message['online']
+        # Don't tell the channel subscriptions a new member has been added if the subscriber data
+        # is already present in the subscriptions hash, i.e. multiple browser windows open.
+        unless subscriptions.has_value? message['channel_data']
+          push payload('pusher_internal:member_added', message['channel_data'])
+        end
+        subscriptions[message['subscription_id']] = message['channel_data']
+      else
+        # Don't tell the channel subscriptions the member has been removed if the subscriber data
+        # still remains in the subscriptions hash, i.e. multiple browser windows open.
+        subscriber = subscriptions.delete message['subscription_id']
+        if subscriber && !subscriptions.has_value?(subscriber)
+          push payload('pusher_internal:member_removed', { user_id: subscriber['user_id'] })
+        end
+      end
+    end
+
+    def payload(event_name, payload = {})
+      Oj.dump({ channel: channel_id, event: event_name, data: payload }, mode: :compat)
+    end
+  end
+end

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