slangerq 0.6.1

data/lib/slanger/api/server.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+require 'sinatra/base'
+require 'signature'
+require 'json'
+require 'active_support/core_ext/hash'
+require 'eventmachine'
+require 'em-hiredis'
+require 'rack'
+require 'fiber'
+require 'rack/fiber_pool'
+require 'oj'
+
+module Slanger
+  module Api
+    class Server < Sinatra::Base
+      use Rack::FiberPool
+      set :raise_errors, lambda { false }
+      set :show_exceptions, false
+
+      error(Signature::AuthenticationError) { |e| halt 401, "401 UNAUTHORIZED" }
+      error(Slanger::Api::InvalidRequest)   { |c| halt 400, "400 Bad Request" }
+
+      before do
+        valid_request
+      end
+
+      post '/apps/:app_id/events' do
+        socket_id = valid_request.socket_id
+        body = valid_request.body
+
+        event = Slanger::Api::Event.new(body["name"], body["data"], socket_id)
+        EventPublisher.publish(valid_request.channels, event)
+
+        status 202
+        return Oj.dump({}, mode: :compat)
+      end
+
+      post '/apps/:app_id/channels/:channel_id/events' do
+        params = valid_request.params
+
+        event = Event.new(params["name"], valid_request.body, valid_request.socket_id)
+        EventPublisher.publish(valid_request.channels, event)
+
+        status 202
+        return Oj.dump({}, mode: :compat)
+      end
+
+      def valid_request
+        @valid_request ||=
+          begin
+            request_body ||= request.body.read.tap{|s| s.force_encoding("utf-8")}
+            RequestValidation.new(request_body, params, env["PATH_INFO"])
+          end
+      end
+    end
+  end
+end

data/lib/slanger/channel.rb

@@ -0,0 +1,106 @@
+# Channel class.
+#
+# Uses an EventMachine channel to let clients interact with the
+# Pusher channel. Relay events received from Redis into the
+# EM channel.
+#
+
+require 'eventmachine'
+require 'forwardable'
+require 'oj'
+
+module Slanger
+  class Channel
+    extend  Forwardable
+
+    def_delegators :channel, :push
+    attr_reader :channel_id
+
+    class << self
+      def from channel_id
+        klass = channel_id[/\Apresence-/] ? PresenceChannel : Channel
+
+        klass.lookup(channel_id) || klass.create(channel_id: channel_id)
+      end
+
+      def lookup(channel_id)
+        all.detect { |o| o.channel_id == channel_id }
+      end
+
+      def create(params = {})
+        new(params).tap { |r| all << r }
+      end
+
+      def all
+        @all ||= []
+      end
+
+      def unsubscribe channel_id, subscription_id
+        from(channel_id).try :unsubscribe, subscription_id
+      end
+
+      def send_client_message msg
+        from(msg['channel']).try :send_client_message, msg
+      end
+    end
+
+    def initialize(attrs)
+      @channel_id = attrs.with_indifferent_access[:channel_id]
+      Slanger::Redis.subscribe channel_id
+    end
+
+    def channel
+      @channel ||= EM::Channel.new
+    end
+
+    def subscribe *a, &blk
+      Slanger::Redis.hincrby('channel_subscriber_count', channel_id, 1).
+        callback do |value|
+          Slanger::Webhook.post name: 'channel_occupied', channel: channel_id if value == 1
+        end
+
+      channel.subscribe *a, &blk
+    end
+
+    def unsubscribe *a, &blk
+      Slanger::Redis.hincrby('channel_subscriber_count', channel_id, -1).
+        callback do |value|
+          Slanger::Webhook.post name: 'channel_vacated', channel: channel_id if value == 0
+        end
+
+      channel.unsubscribe *a, &blk
+    end
+
+
+    # Send a client event to the EventMachine channel.
+    # Only events to channels requiring authentication (private or presence)
+    # are accepted. Public channels only get events from the API.
+    def send_client_message(message)
+      Slanger::Redis.publish(message['channel'], Oj.dump(message, mode: :compat)) if authenticated?
+    end
+
+    # Send an event received from Redis to the EventMachine channel
+    # which will send it to subscribed clients.
+    def dispatch(message, channel)
+      push(Oj.dump(message, mode: :compat)) unless channel =~ /\Aslanger:/
+
+      perform_client_webhook!(message)
+    end
+
+    def authenticated?
+      channel_id =~ /\Aprivate-/ || channel_id =~ /\Apresence-/
+    end
+
+    private
+
+    def perform_client_webhook!(message)
+      if (message['event'].start_with?('client-')) then
+
+        event = message.merge({'name' => 'client_event'})
+        event['data'] = Oj.dump(event['data'])
+
+        Slanger::Webhook.post(event)
+      end
+    end
+  end
+end

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