sinapse 0.1.0

data/lib/sinapse/authentication.rb

@@ -0,0 +1,44 @@
+require 'securerandom'
+
+module Sinapse
+  def self.generate_token
+    SecureRandom.urlsafe_base64(64)
+  end
+
+  # TODO: #get to return the token (if any)
+  class Authentication < Struct.new(:record)
+    def reset
+      clear
+      generate
+    end
+
+    def generate
+      Sinapse.redis do |redis|
+        loop do
+          token = Sinapse.generate_token
+          if redis.setnx(token_key(token), record.to_param)
+            redis.set(key, token)
+            return token
+          end
+        end
+      end
+    end
+
+    def clear
+      Sinapse.redis do |redis|
+        if token = redis.get(key)
+          redis.del(token_key(token))
+          redis.del(key)
+        end
+      end
+    end
+
+    def token_key(token)
+      "sinapse:tokens:#{token}"
+    end
+
+    def key
+      "sinapse:#{record.class.name}:#{record.to_param}"
+    end
+  end
+end

data/lib/sinapse/channels.rb

@@ -0,0 +1,51 @@
+module Sinapse
+  # TODO: #access_token to return the current user token (or generate one if missing)
+  class Channels < Struct.new(:record)
+    def auth
+      @auth ||= Authentication.new(record)
+    end
+
+    def channels
+      Sinapse.redis { |redis| redis.smembers(key) }
+    end
+
+    def has_channel?(channel)
+      Sinapse.redis { |redis| redis.sismember(key, channel_for(channel)) }
+    end
+
+    def add_channel(channel)
+      Sinapse.redis do |redis|
+        redis.sadd(key, channel_for(channel))
+        redis.publish(key(:add), channel_for(channel))
+      end
+    end
+
+    def remove_channel(channel)
+      Sinapse.redis do |redis|
+        redis.srem(key, channel_for(channel))
+        redis.publish(key(:remove), channel_for(channel))
+      end
+    end
+
+    # Removes all channels at once.
+    def clear
+      channels.each { |channel| remove_channel(channel) }
+    end
+
+    # Removes all channels and clears authentication.
+    def destroy
+      channels.each { |channel| remove_channel(channel) }
+      auth.clear
+    end
+
+    def channel_for(record)
+      record.is_a?(String) ? record : record.sinapse_channel
+    end
+
+    def key(extra = nil)
+      key = "sinapse:channels:#{record.to_param}"
+      key += ":#{extra}" if extra
+      key
+    end
+  end
+end

data/lib/sinapse/config.rb

@@ -0,0 +1,31 @@
+module Sinapse
+  module Config
+    extend self
+
+    def retry
+      default(:SINAPSE_RETRY, 5).to_i * 1000
+    end
+
+    def keep_alive
+      default(:SINAPSE_KEEP_ALIVE, 15).to_i
+    end
+
+    def cors_origin
+      default(:SINAPSE_CORS_ORIGIN, '*')
+    end
+
+    def channel_event
+      !ENV["SINAPSE_CHANNEL_EVENT"].nil?
+    end
+
+    private
+
+      def default(name, default_value)
+        if ENV.has_key?(name.to_s)
+          ENV[name.to_s]
+        else
+          default_value.to_s
+        end
+      end
+  end
+end

data/lib/sinapse/cross_origin_resource_sharing.rb

@@ -0,0 +1,79 @@
+module Sinapse
+  module Rack
+    class CrossOriginResourceSharing
+      include Goliath::Rack::AsyncMiddleware
+
+      def initialize(app, options = {})
+        super(app)
+
+        @origin  = options[:origin] || '*'
+        @methods = options[:methods] || %w(GET POST)
+        @max_age = options[:max_age]
+      end
+
+      def call(env)
+        env['HTTP_ORIGIN'] ||= env['HTTP_X_ORIGIN']
+        env['cors.headers'] = nil
+
+        if env['HTTP_ORIGIN']
+          if env['REQUEST_METHOD'] == 'OPTIONS' && env['HTTP_ACCESS_CONTROL_REQUEST_METHOD']
+            return [200, preflight_headers(env), ''] if allowed?(env)
+            return [400, {}, '']
+          end
+
+          if allowed_origin?(env['HTTP_ORIGIN']) && allowed_method?(env['REQUEST_METHOD'])
+            env['cors.headers'] = response_headers(env)
+          end
+        end
+
+        super(env)
+      end
+
+      def post_process(env, status, headers, body)
+        augmented_headers = headers.merge(env['cors.headers']) if env['cors.headers']
+        [status, augmented_headers || headers, body]
+      end
+
+      private
+
+        def allowed?(env)
+          allowed_origin?(env['HTTP_ORIGIN']) &&
+            allowed_method?(env['HTTP_ACCESS_CONTROL_REQUEST_METHOD'])
+        end
+
+        def allowed_origin?(origin)
+          case @origin
+          when Regexp
+            @origin =~ origin
+          when '*'
+            true
+          else
+            origin == @origin || origin =~ %r(^https?://#{@origin})
+          end
+        end
+
+        def allowed_method?(method)
+          methods.include?(method.to_s.upcase)
+        end
+
+        def methods
+          @methods.map { |m| m.to_s.upcase }
+        end
+
+        def preflight_headers(env)
+          response_headers(env).merge(
+            'Content-Type' => 'text/plain',
+            'Access-Control-Allow-Headers' => env['HTTP_ACCESS_CONTROL_REQUEST_HEADERS'],
+          )
+        end
+
+        def response_headers(env)
+          {
+            'Access-Control-Allow-Origin' => env['HTTP_ORIGIN'],
+            'Access-Control-Allow-Methods' => methods.join(', '),
+            'Access-Control-Max-Age' => @max_age.to_s
+          }
+        end
+    end
+  end
+end

data/lib/sinapse/keep_alive.rb

@@ -0,0 +1,25 @@
+module Sinapse
+  class KeepAlive
+    def initialize
+      @queue = []
+    end
+
+    def <<(env)
+      @queue << env
+      @timer = start if @queue.size == 1
+    end
+
+    def delete(env)
+      @queue.delete(env)
+      @timer.cancel if @timer && @queue.size == 0
+    end
+
+    protected
+
+      def start
+        EM.add_periodic_timer(Config.keep_alive) do
+          @queue.each { |env| env.chunked_stream_send ":\n" }
+        end
+      end
+  end
+end

data/lib/sinapse/publishable.rb

@@ -0,0 +1,26 @@
+require 'active_support/core_ext/string/inflections'
+require 'msgpack'
+
+module Sinapse
+  module Publishable
+    def self.included(klass)
+      klass.__send__ :alias_method, :publish, :sinapse_publish unless klass.respond_to?(:publish)
+    end
+
+    def sinapse_publish(message, options = nil)
+      data = Publishable.pack(message, options)
+      Sinapse.redis { |redis| redis.publish(sinapse_channel, data) }
+    end
+
+    def sinapse_channel
+      [self.class.name.underscore.singularize, self.to_param].join(':')
+    end
+
+    private
+
+      def self.pack(message, options)
+        data = options.is_a?(Hash) && options[:event] ? [options[:event].to_s, message.to_s] : message.to_s
+        MessagePack.pack(data)
+      end
+  end
+end

data/lib/sinapse/server.rb

@@ -0,0 +1,113 @@
+require 'goliath'
+require 'sinapse/config'
+require 'sinapse/keep_alive'
+require 'sinapse/cross_origin_resource_sharing'
+require 'msgpack'
+
+module Sinapse
+  class Server < Goliath::API
+    use Sinapse::Rack::CrossOriginResourceSharing, origin: Config.cors_origin
+    use Goliath::Rack::Params
+    use Goliath::Rack::Heartbeat  # respond to /status with 200, OK (monitoring, etc)
+    use Goliath::Rack::Validation::RequestMethod, %w(GET POST)
+    use Goliath::Rack::Validation::RequiredParam, { key: 'access_token' }
+
+    def keep_alive
+      @keep_alive ||= KeepAlive.new
+    end
+
+    def on_close(env)
+      close_redis(env['redis']) if env['redis']
+      keep_alive.delete(env)
+    end
+
+    def response(env)
+      env['redis'] = Redis.new(:driver => :synchrony, :url => Sinapse.config[:url])
+
+      user, channels = authenticate(env)
+      return [401, {}, []] if user.nil? || channels.empty?
+
+      EM.next_tick do
+        sse(env, :ok, :authentication, retry: Config.retry)
+        subscribe(env, user, channels)
+        keep_alive << env
+      end
+
+      chunked_streaming_response(200, response_headers(env))
+    end
+
+    private
+
+      def authenticate(env)
+        user = env['redis'].get("sinapse:tokens:#{params['access_token']}")
+        if user
+          channels = env['redis'].smembers("sinapse:channels:#{user}")
+          [user, channels]
+        end
+      end
+
+      def subscribe(env, user, channels)
+        EM.synchrony do
+          env['redis'].psubscribe("sinapse:channels:#{user}:*") do |on|
+            on.psubscribe do
+              env['redis'].subscribe(*channels)
+            end
+
+            on.pmessage do |_, channel, message|
+              update_subscriptions(env, message, channel)
+            end
+
+            on.message do |channel, data|
+              event, message = unpack(channel, data)
+              sse(env, message, event)
+            end
+          end
+          env['redis'].quit
+        end
+      end
+
+      def update_subscriptions(env, message, channel)
+        return env['redis'].subscribe(message)   if channel.end_with?(':add')
+        return env['redis'].unsubscribe(message) if channel.end_with?(':remove')
+      end
+
+      def unpack(channel, data)
+        message = MessagePack.unpack(data)
+        if message.is_a?(Array)
+          message
+        else
+          event = Config.channel_event ? channel : nil
+          [event, message]
+        end
+      end
+
+      def sse(env, data, event = nil, options = {})
+        message = []
+        message << "retry: %d" % options[:retry] if options[:retry]
+        message << "id: %d" % options[:id] if options[:id]
+        message << "event: %s" % event if event
+        message << "data: %s" % data.to_s.gsub(/\n/, "\ndata: ")
+        env.chunked_stream_send message.join("\n") + "\n\n"
+      end
+
+      def close_redis(redis)
+        if redis.subscribed?
+          redis.unsubscribe
+        else
+          redis.quit
+        end
+      end
+
+      def response_headers(env)
+        headers = {
+          'Connection' => 'close',
+          'Content-Type' => 'text/event-stream'
+        }
+        if env['cors.headers']
+          headers.merge(env['cors.headers'])
+        else
+          headers
+        end
+      end
+  end
+end

data/lib/sinapse/version.rb

@@ -0,0 +1,10 @@
+module Sinapse
+  def self.version
+    Gem::Version.new File.read(File.expand_path('../../../VERSION', __FILE__))
+  end
+
+  module VERSION
+    MAJOR, MINOR, TINY, PRE = Sinapse.version.segments
+    STRING = Sinapse.version.to_s
+  end
+end

data/sinapse.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sinapse/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Julien Portalier"]
+  gem.email         = ["julien@portalier.com"]
+  gem.description   = gem.summary = "An EventSource push service for Ruby"
+  gem.homepage      = "http://github.com/ysbaddaden/sinapse"
+  gem.license       = "MIT"
+
+  gem.executables   = ['sinapse']
+  gem.files         = `git ls-files | grep -Ev '^example'`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = "sinapse"
+  gem.require_paths = ["lib"]
+  gem.version       = Sinapse::VERSION::STRING
+
+  gem.cert_chain    = ['certs/ysbaddaden.pem']
+  gem.signing_key   = File.expand_path('~/.ssh/gem-private_key.pem') if $0 =~ /gem\z/
+
+  gem.add_dependency 'goliath', '>= 1.0.3'
+  gem.add_dependency 'redis', '>= 3.0.6'
+  gem.add_dependency 'hiredis'
+  gem.add_dependency 'connection_pool'
+  gem.add_dependency 'msgpack', '>= 0.5.0'
+  gem.add_dependency 'activesupport', '>= 3.0.0'
+
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'em-http-request'
+  gem.add_development_dependency 'minitest', '>= 5.2.0'
+  gem.add_development_dependency 'minitest-reporters'
+end

data/test/authentication_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+describe "Sinapse::Authentication" do
+  after do
+    Sinapse.redis do |redis|
+      redis.keys('sinapse:*').each { |key| redis.del(key) }
+    end
+  end
+
+  let(:user) { User.new(rand(1..100)) }
+  let(:auth) { user.sinapse.auth }
+
+  it "key" do
+    assert_equal "sinapse:User:1", User.new(1).sinapse.auth.key
+    assert_equal "sinapse:Admin:456", Admin.new(456).sinapse.auth.key
+  end
+
+  describe "generate" do
+    it "must generate token" do
+      Sinapse.stub(:generate_token, 'valid') do
+        assert_equal 'valid', auth.generate
+
+        Sinapse.redis do |redis|
+          assert_equal 'valid', redis.get(auth.key)
+          assert_equal user.to_param, redis.get(auth.token_key('valid'))
+        end
+      end
+    end
+
+    it "won't use an existing token" do
+      tokens = ['first', 'first', 'second']
+
+      Sinapse.stub(:generate_token, lambda { tokens.shift }) do
+        User.new(2).sinapse.auth.generate
+        assert_equal 'second', auth.generate
+
+        Sinapse.redis do |redis|
+          assert_equal 'second', redis.get(auth.key)
+        end
+      end
+    end
+  end
+
+  it "clear" do
+    Sinapse.stub(:generate_token, 'a1b2c3d4e5f6') do
+      auth.generate
+      auth.clear
+
+      Sinapse.redis do |redis|
+        assert_nil redis.get(auth.key)
+        assert_nil redis.get(auth.token_key('a1b2c3d4e5f6'))
+      end
+    end
+  end
+
+  it "reset" do
+    tokens = ['first', 'second']
+
+    Sinapse.stub(:generate_token, lambda { tokens.shift }) do
+      auth.generate
+      auth.reset
+
+      Sinapse.redis do |redis|
+        assert_equal 'second', redis.get(auth.key)
+        assert_equal user.to_param, redis.get(auth.token_key('second'))
+      end
+    end
+  end
+end