oceanex-slanger 0.7.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.blank? || invalid_signature?
+
+      Subscription.new(connection.socket, connection.socket_id, @msg).subscribe
+    end
+  end
+end

data/lib/slanger/redis.rb

@@ -0,0 +1,65 @@
+# Redis class.
+# Interface with Redis.
+
+require "forwardable"
+require "oj"
+
+module Slanger
+  module Redis
+    extend Forwardable
+
+    def_delegators :subscriber, :subscribe
+
+    def regular_connection
+      @regular_connection ||= new_connection
+    end
+
+    def publisher
+      @publisher ||= new_connection
+    end
+
+    def send_command(method, *arg)
+      regular_connection.send(method, *arg)
+    end
+
+    def hincrby(*arg)
+      send_command :hincrby, *arg
+    end
+
+    def hset(*arg)
+      send_command :hset, *arg
+    end
+
+    def hdel(*arg)
+      send_command :hdel, *arg
+    end
+
+    def hgetall(*arg)
+      send_command :hgetall, *arg
+    end
+
+    def publish(*arg)
+      publish_event(:publish, *arg)
+    end
+
+    def publish_event(method, *args)
+      publisher.send(method, *args)
+    end
+
+    def subscriber
+      @subscriber ||= new_connection.pubsub.tap do |c|
+        c.on(:message) do |channel, message|
+          message = Oj.strict_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.7.1"
+end

data/lib/slanger/web_socket_server.rb

@@ -0,0 +1,38 @@
+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,65 @@
+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,113 @@
+#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