redisse 0.4.0

data/lib/redisse/server/redis.rb

@@ -0,0 +1,39 @@
+module Redisse
+  module Server::Redis
+    def redis
+      @redis ||= EM::Hiredis.connect(redisse.redis_server)
+    end
+
+    def pubsub(&on_disconnected)
+      ensure_pubsub
+      return false unless @pubsub.connected?
+      @pubsub_errbacks << on_disconnected
+      true
+    end
+
+    def ensure_pubsub
+      return if defined? @pubsub
+      @pubsub = redis.pubsub
+      @pubsub_errbacks = []
+      @pubsub.on(:disconnected, &method(:on_redis_close))
+      EM::Synchrony.sync(@pubsub)
+    end
+
+    def on_redis_close
+      @pubsub_errbacks.each(&:call)
+      @pubsub_errbacks.clear
+    end
+
+    def pubsub_subcribe(channels, callback)
+      channels.each do |channel|
+        @pubsub.subscribe(channel, callback)
+      end
+    end
+
+    def pubsub_unsubscribe_proc(channels, callback)
+      channels.each do |channel|
+        @pubsub.unsubscribe_proc(channel, callback)
+      end
+    end
+  end
+end

data/lib/redisse/server/responses.rb

@@ -0,0 +1,22 @@
+module Redisse
+  module Server::Responses
+    def plain_response(message = nil, code)
+      message ||= "#{code} #{Goliath::HTTP_STATUS_CODES.fetch(code)}\n"
+      Rack::Response.new(message, code, 'Content-Type' => 'text/plain')
+    end
+
+    def not_acceptable
+      plain_response "406 Not Acceptable\n" \
+        "This resource can only be represented as text/event-stream.\n",
+        406
+    end
+
+    def not_found
+      plain_response 404
+    end
+
+    def service_unavailable
+      plain_response 503
+    end
+  end
+end

data/lib/redisse/server/stats.rb

@@ -0,0 +1,10 @@
+module Redisse
+  class Server::Stats
+    def initialize(address, port, config, status, logger)
+      status[:stats] = Hash.new(0)
+    end
+
+    def run
+    end
+  end
+end

data/lib/redisse/server_sent_events.rb

@@ -0,0 +1,17 @@
+module Redisse
+  module ServerSentEvents
+
+  module_function
+
+    def server_sent_event(data, type: nil, id: nil, **options)
+      data = String(data)
+      str = ''
+      str << "retry: #{options[:retry]}\n" if options[:retry]
+      str << "id: #{id}\n" if id
+      str << "event: #{type}\n" if type
+      str << "data: " + data.gsub("\n", "\ndata: ") + "\n"
+      str << "\n"
+    end
+
+  end
+end

data/lib/redisse/version.rb

@@ -0,0 +1,3 @@
+module Redisse
+  VERSION = "0.4.0"
+end

data/redisse.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redisse/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "redisse"
+  spec.version       = Redisse::VERSION
+  spec.authors       = ["Étienne Barrié", "Julien Blanchard"]
+  spec.email         = ["etienne.barrie@gmail.com", "julien@sideburns.eu"]
+  spec.summary       = %q{Server-Sent Events via Redis}
+  spec.homepage      = "https://github.com/tigerlily/redisse"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard-tomdoc"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "dotenv"
+  spec.add_runtime_dependency "goliath"
+  spec.add_runtime_dependency "em-hiredis"
+  spec.add_runtime_dependency "redis"
+end

data/spec/example_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_system_helper'
+require 'dotenv'
+Dotenv.load 'example/.env'
+
+REDIS_PORT    = ENV['REDIS_PORT']
+REDISSE_PORT  = ENV['REDISSE_PORT']
+REDISSE_REDIS = ENV['REDISSE_REDIS']
+
+describe "Example" do
+  BIN = __dir__ + '/../example/bin/'
+  GEM_BIN = __dir__ + '/../bin/'
+
+  include_context "system"
+
+  describe "basic tests" do
+    before :context do
+      @redis   = run_server "#{BIN}redis",       REDIS_PORT, pidfile: 'redis.pid'
+      @redisse = run_server "#{GEM_BIN}redisse", REDISSE_PORT
+      @redis.wait_tcp
+      @redisse.wait_tcp
+    end
+
+    after :context do
+      @redis.stop
+      @redisse.stop
+    end
+
+    it "refuses a connection with 406 without proper Accept header" do
+      uri = URI(redisse_url)
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        request = Net::HTTP::Get.new uri
+        response = http.request request
+        expect(response.code).to be == "406"
+      end
+    end
+
+    it "refuses a connection with 404 without channels" do
+      reader = EventReader.open redisse_url
+      expect(reader).not_to be_connected
+      expect(reader.response.code).to be == "404"
+    end
+
+    it "receives a message" do
+      reader = EventReader.open redisse_url :global
+      expect(reader).to be_connected
+      publish :global, :foo, :bar
+      reader.each do |event|
+        expect(event.type).to be == 'foo'
+        expect(event.data).to be == 'bar'
+        reader.close
+      end
+      expect(reader).not_to be_connected
+    end
+
+    it "receives different messages on different channels" do
+      reader_1 = EventReader.open redisse_url :global, :channel_1
+      reader_2 = EventReader.open redisse_url :global, :channel_2
+      expect(reader_1).to be_connected
+      expect(reader_2).to be_connected
+      publish :global,    :foo, :foo_data
+      publish :channel_1, :bar, :bar_data
+      publish :channel_2, :baz, :baz_data
+      events_1 = reader_1.each.take(2)
+      events_2 = reader_2.each.take(2)
+      expect(events_1.map(&:type)).to be == %w(foo bar)
+      expect(events_1.map(&:data)).to be == %w(foo_data bar_data)
+      expect(events_2.map(&:type)).to be == %w(foo baz)
+      expect(events_2.map(&:data)).to be == %w(foo_data baz_data)
+      reader_1.close
+      reader_2.close
+    end
+
+    it "closes the connection after a second with long polling" do
+      reader = EventReader.open redisse_url :global, :polling
+      expect(reader).to be_connected
+      publish :global, :foo, :bar
+      time = Time.now.to_f
+      publish :global, :foo, :baz
+      received = nil
+      expect {
+        begin
+          Timeout.timeout(2) do
+            received = reader.each.to_a
+          end
+        rescue Timeout::Error
+        end
+        time = Time.now.to_f
+      }.to change { time }.by(a_value_within(0.2).of(1.0))
+      expect(reader).not_to be_connected
+      expect(received.size).to be == 2
+      expect(received.map(&:data)).to be == %w(bar baz)
+    end
+
+    it "sends a heartbeat", :slow do
+      reader = EventReader.open redisse_url :global
+      expect(reader).to be_connected
+      expect(reader.full_stream).to be_empty
+      sleep(16)
+      expect(reader.full_stream).to match(/^: hb$/)
+      reader.close
+    end
+
+    it "sends history" do
+      event_id = publish :global, :foo, :foo_data
+      expect(event_id).not_to be_nil
+      publish :global,    :foo, :hist_1
+      publish :channel_1, :foo, :hist_2
+      events = EventReader.open redisse_url(:global, :channel_1), event_id do |reader|
+        reader.each.take(2)
+      end
+      expect(events.map(&:data)).to be == %w(hist_1 hist_2)
+    end
+
+    let(:history_size) { 100 }
+
+    describe "sends a missedevents events" do
+      example "if full history could not be fetched" do
+        event_id = publish :global, :foo, :foo_data
+        publish :global, :foo, :missed
+        publish :global, :foo, :first
+        publish :global, :foo, :foo_data, count: history_size - 2
+        publish :global, :foo, :'last straw'
+        events = EventReader.open redisse_url(:global), event_id do |reader|
+          enum = reader.each
+          event = enum.next
+          expect(event.type).to be == 'missedevents'
+          enum.take(history_size)
+        end
+        expect(events.first.data).to be == 'first'
+        expect(events[1...-1].map(&:data)).to all be == 'foo_data'
+        expect(events.last.data).to be == 'last straw'
+      end
+
+      example "if full history was fetched but the server can't know if there were missed events" do
+        event_id = publish :global, :foo, :foo_data
+        publish :global, :foo, :first
+        publish :global, :foo, :foo_data, count: history_size - 2
+        publish :global, :foo, :'last straw'
+        events = EventReader.open redisse_url(:global), event_id do |reader|
+          enum = reader.each
+          event = enum.next
+          expect(event.type).to be == 'missedevents'
+          enum.take(history_size)
+        end
+        expect(events.first.data).to be == 'first'
+        expect(events[1...-1].map(&:data)).to all be == 'foo_data'
+        expect(events.last.data).to be == 'last straw'
+      end
+    end
+
+    it "stores 100 events per channel for history" do
+      event_id = publish :global, :foo, :seen
+      publish :global,    :foo, :foo_data, count: history_size - 1
+      publish :channel_1, :bar, :bar_data, count: history_size
+      events = EventReader.open redisse_url(:global, :channel_1), event_id do |reader|
+        reader.each.take(2 * history_size - 1)
+      end
+      expect(events.first(history_size - 1).map(&:type)).to all be == 'foo'
+      expect(events.last(history_size).map(&:type))     .to all be == 'bar'
+    end
+  end
+
+  describe "Redis failures" do
+    before :context do
+      @redis   = run_server "#{BIN}redis",       REDIS_PORT, pidfile: 'redis.pid'
+      @redisse = run_server "#{GEM_BIN}redisse", REDISSE_PORT
+      @redis.wait_tcp
+      @redisse.wait_tcp
+    end
+
+    after :context do
+      @redis.stop
+      @redisse.stop
+    end
+
+    it "disconnects then refuses connections with 503" do
+      reader = EventReader.open redisse_url :global
+      expect(reader).to be_connected
+      @redis.stop
+      Timeout.timeout(0.1) do
+        reader.each.to_a
+      end
+      expect(reader).not_to be_connected
+      reader = EventReader.open redisse_url :global
+      expect(reader).not_to be_connected
+      expect(reader.response.code).to be == "503"
+    end
+
+  end
+
+  def publish(channel, type, data, count: nil)
+    count = "N=#{count}" if count
+    output = `#{BIN}/publish '#{channel}' '#{type}' '#{data}' #{count}`
+    output[/(\d+)/, 1]
+  end
+
+  def redisse_url(*channels)
+    "http://localhost:#{REDISSE_PORT}/?#{URI.encode_www_form(channels)}"
+  end
+end

data/spec/publisher_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'redisse'
+
+module Events
+  extend Redisse
+end
+
+describe "Publishing events" do
+  context "basic usage" do
+    before do
+      Events.test_mode!
+    end
+
+    it "has no events initially" do
+      expect(Events.published.size).to be == 0
+    end
+
+    it "keeps the published events" do
+      Events.publish :global, foo: 'bar'
+      expect(Events.published.size).to be == 1
+      Events.publish :global, foo: 'baz'
+      expect(Events.published.size).to be == 2
+    end
+
+    it "gives access to the event channel, type and data" do
+      Events.publish :global, foo: 'bar'
+      event = Events.published.first
+      expect(event.channel).to be == :global
+      expect(event.type).to    be == :foo
+      expect(event.data).to    be == 'bar'
+    end
+
+    it "parses data as JSON" do
+      Events.publish :global, foo: JSON.dump(bar: 'baz')
+      json = Events.published.first.json
+      expect(json['bar']).to be == 'baz'
+    end
+  end
+
+  context "with a filter" do
+    it "filters by a simple event type" do
+      Events.test_filter = :foo
+      Events.publish :global, foo: 'bar'
+      Events.publish :global, bar: 'bar'
+      expect(Events.published.size).to       be == 1
+      expect(Events.published.first.type).to be == :foo
+    end
+
+    it "filters with a Proc" do
+      Events.test_filter = -> type { %i(foo bar).include? type }
+      Events.publish :global, foo: 'bar'
+      Events.publish :global, bar: 'bar'
+      Events.publish :global, baz: 'bar'
+      expect(Events.published.size).to be == 2
+    end
+  end
+
+  it "fails if test mode is not set" do
+    events = Module.new.extend Redisse
+    expect {
+      events.published
+    }.to raise_error(/\.test_mode!/)
+  end
+
+  describe "TestEvent" do
+    require 'yaml'
+
+    class Redisse::TestEvent
+      def yml
+        YAML.load data
+      end
+    end
+
+    it "can be extended" do
+      Events.test_mode!
+      Events.publish :global, foo: YAML.dump(bar: 'baz')
+      yml = Events.published.first.yml
+      expect(yml[:bar]).to be == 'baz'
+    end
+  end
+end

data/spec/redirect_endpoint_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'redisse'
+require 'rack/test'
+
+describe "Redirect endpoint" do
+  include Rack::Test::Methods
+
+  let :redisse do
+    Module.new do
+      extend Redisse
+
+      def self.channels(env)
+        %w(global)
+      end
+
+      self.nginx_internal_url = '/internal'
+    end
+  end
+
+  def app
+    redirect_endpoint = redisse.redirect_endpoint
+    Rack::Builder.new do
+      use Rack::Lint
+      run redirect_endpoint
+    end
+  end
+
+  it "is a Rack app" do
+    expect(redisse.redirect_endpoint).to respond_to(:call)
+  end
+
+  it "returns a 200 OK" do
+    get '/'
+    expect(last_response).to be_ok
+  end
+
+  def redirect_url(uri = '/')
+    get uri
+    last_response['X-Accel-Redirect']
+  end
+
+  it "redirects to the nginx_internal_url" do
+    redisse.nginx_internal_url = '/foo/'
+    expect(redirect_url).to start_with "/foo/"
+  end
+
+  it "forces a slash at the end" do
+    redisse.nginx_internal_url = '/foo'
+    expect(redirect_url).to start_with "/foo/"
+  end
+
+  def redirect_params(uri = '/')
+    query = redirect_url(uri).split('?', 2).last
+    URI.decode_www_form(query)
+  end
+
+  describe "passing channels" do
+    it "passes the channels as query params" do
+      def redisse.channels(env)
+        %w(foo bar)
+      end
+      expect(redirect_params.map(&:first)).to be == %w(foo bar)
+    end
+
+    %w(lastEventId polling).each do |reserved|
+      it "fails for the reserved channel name '#{reserved}'" do
+        def redisse.channels(env)
+          [reserved]
+        end
+        expect { get '/' }.to raise_error(/reserved/i)
+      end
+    end
+  end
+
+  describe "query params" do
+    it "passes the lastEventId param" do
+      params = redirect_params('/?lastEventId=42')
+      expect(params.assoc('lastEventId')).not_to be_nil
+    end
+
+    it "passes the polling param" do
+      params = redirect_params('/?polling')
+      expect(params.assoc('polling')).not_to be_nil
+    end
+
+    it "passes lastEventId and polling params" do
+      params = redirect_params('/?lastEventId=42&polling')
+      expect(params.assoc('lastEventId')).not_to be_nil
+      expect(params.assoc('polling')).not_to be_nil
+    end
+
+    it "ignores other params" do
+      params = redirect_params('/?foo')
+      expect(params.assoc('foo')).to be_nil
+    end
+  end
+
+end