oceanex-slanger 0.7.1

data/lib/slanger/api/server.rb

@@ -0,0 +1,56 @@
+# 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,104 @@
+# 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-"))
+        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.strict_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,117 @@
+# 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.strict_load(msg)
+
+      msg["data"] = Oj.strict_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,8 @@
+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.strict_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