pubsubstub 0.0.15 → 0.1.0.beta1

data/lib/pubsubstub/redis_pub_sub.rb

@@ -1,73 +0,0 @@
-module Pubsubstub
-  class RedisPubSub
-    EVENT_SCORE_THRESHOLD = 1000
-    EXPIRE_THRESHOLD = 24 * 60 * 60
-
-    def initialize(channel_name)
-      @channel_name = channel_name
-    end
-
-    def subscribe(callback)
-      self.class.sub.subscribe(key('pubsub'), callback)
-    end
-
-    def unsubscribe(callback)
-      self.class.sub.unsubscribe_proc(key('pubsub'), callback)
-    end
-
-    def publish(event)
-      self.class.publish(@channel_name, event)
-    end
-
-    def scrollback(since_event_id)
-      redis_scrollback(since_event_id) do |json|
-        yield Pubsubstub::Event.from_json(json)
-      end
-    end
-
-    private
-
-    def redis_scrollback(since_event_id, &block)
-      args = [key('scrollback'), "(#{since_event_id.to_i}", '+inf']
-      if EventMachine.reactor_running?
-        self.class.nonblocking_redis.zrangebyscore(*args) do |events|
-          events.each(&block)
-        end
-      else
-        self.class.blocking_redis.zrangebyscore(*args).each(&block)
-      end
-    end
-
-    def key(purpose)
-      [@channel_name, purpose].join(".")
-    end
-
-    class << self
-      def publish(channel_name, event)
-        scrollback = "#{channel_name}.scrollback"
-        blocking_redis.pipelined do
-          blocking_redis.publish("#{channel_name}.pubsub", event.to_json)
-          blocking_redis.zadd(scrollback, event.id, event.to_json)
-          blocking_redis.zremrangebyrank(scrollback, 0, -EVENT_SCORE_THRESHOLD)
-          blocking_redis.expire(scrollback, EXPIRE_THRESHOLD)
-        end
-      end
-
-      def sub
-        @sub ||= nonblocking_redis.pubsub
-      end
-
-      def blocking_redis
-        @blocking_redis ||= Redis.new(url: redis_url)
-      end
-
-      def nonblocking_redis
-        @nonblocking_redis ||= EM::Hiredis.connect(redis_url)
-      end
-
-      def redis_url
-        Pubsubstub.redis_url || ENV['REDIS_URL'] || "redis://localhost:6379/0"
-      end
-    end
-  end
-end

data/spec/redis_pub_sub_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-
-describe Pubsubstub::RedisPubSub do
-
-  context "class singleton methods" do
-    subject { Pubsubstub::RedisPubSub }
-
-    describe "#publish" do
-      let(:redis) { double('redis') }
-      let(:event) { double('Event', to_json: "event_data", id: 1234) }
-      before {
-        allow(redis).to receive(:pipelined).and_yield
-      }
-
-      it "publishes the event to a redis channel and adds it to the scrollback" do
-        allow(subject).to receive(:blocking_redis) { redis }
-        expect(redis).to receive(:publish).with("test.pubsub", event.to_json)
-        expect(redis).to receive(:zadd).with("test.scrollback", event.id, event.to_json)
-        expect(redis).to receive(:zremrangebyrank).with("test.scrollback", 0, -1000)
-        expect(redis).to receive(:expire).with("test.scrollback", Pubsubstub::RedisPubSub::EXPIRE_THRESHOLD)
-        subject.publish("test", event)
-      end
-
-      it "truncates the scrollback" do
-        count = Pubsubstub::RedisPubSub::EVENT_SCORE_THRESHOLD
-        (1...count).each do |id|
-          event = double(to_json: "event_data #{id}", id: id)
-          subject.publish('test', event)
-        end
-        expect(subject.blocking_redis.zcard("test.scrollback")).to eq(count - 1)
-
-        event = double(to_json: "event_data N", id: count)
-        subject.publish('test', event)
-        expect(subject.blocking_redis.zcard("test.scrollback")).to eq(count - 1)
-      end
-    end
-
-    describe "#redis_url" do
-      it "uses the fallback url fallback chain" do
-        Pubsubstub.redis_url = "redis://localhost:6379/1"
-        expect(Pubsubstub::RedisPubSub.redis_url).to eq("redis://localhost:6379/1")
-
-        Pubsubstub.redis_url = nil
-        ENV['REDIS_URL'] = "redis://localhost:6379/2"
-        expect(Pubsubstub::RedisPubSub.redis_url).to eq("redis://localhost:6379/2")
-
-        Pubsubstub::RedisPubSub.instance_variable_set(:@blocking_redis, nil)
-        ENV['REDIS_URL'] = nil
-        expect(Pubsubstub::RedisPubSub.redis_url).to eq("redis://localhost:6379/0")
-      end
-    end
-  end
-
-  context "pubsub" do
-    subject { Pubsubstub::RedisPubSub.new("test") }
-    let(:pubsub) { double('redis pubsub') }
-    let(:callback) { ->{} }
-
-    describe "#subscribe" do
-      before {
-        allow(subject.class).to receive(:sub) { pubsub }
-      }
-
-      it "creates a redis sub with the callback" do
-        expect(pubsub).to receive(:subscribe).with("test.pubsub", callback)
-        subject.subscribe(callback)
-      end
-    end
-
-    describe "#unsubscribe" do
-      before {
-        allow(subject.class).to receive(:sub) { pubsub }
-      }
-
-      it "creates a redis sub with the callback" do
-        expect(pubsub).to receive(:unsubscribe_proc).with("test.pubsub", callback)
-        subject.unsubscribe(callback)
-      end
-    end
-
-    describe "#publish" do
-      let(:event) { Pubsubstub::Event.new("toto") }
-      it "delegates to RedisPubSub.publish" do
-        expect(Pubsubstub::RedisPubSub).to receive(:publish).with("test", event)
-        subject.publish(event)
-      end
-    end
-  end
-
-  describe "#scrollback" do
-    subject { Pubsubstub::RedisPubSub.new("test") }
-
-    let(:event1) { Pubsubstub::Event.new("toto", id: 1235) }
-    let(:event2) { Pubsubstub::Event.new("toto", id: 1236) }
-
-    describe "without EventMachine" do
-      it "yields the events in the scrollback" do
-        redis = double('redis')
-        expect(redis).to receive(:zrangebyscore)
-          .with('test.scrollback', '(1234', '+inf')
-          .and_return([event1.to_json, event2.to_json])
-
-        expect(Pubsubstub::RedisPubSub).to receive(:blocking_redis).and_return(redis)
-        expect { |block| subject.scrollback(1234, &block) }.to yield_successive_args(event1, event2)
-      end
-    end
-
-    describe "with EventMachine" do
-      it "yields the events in the scrollback" do
-        allow(EventMachine).to receive(:reactor_running?).and_return(true)
-        redis = double('redis')
-        expect(redis).to receive(:zrangebyscore)
-          .with('test.scrollback', '(1234', '+inf')
-          .and_yield([event1.to_json, event2.to_json])
-
-        expect(Pubsubstub::RedisPubSub).to receive(:nonblocking_redis).and_return(redis)
-        expect { |block| subject.scrollback(1234, &block) }.to yield_successive_args(event1, event2)
-      end
-    end
-  end
-end