chasqui 0.9.3 → 1.0.0.pre.rc1

data/lib/chasqui/queue_adapter.rb

@@ -0,0 +1,14 @@
+module Chasqui
+  module QueueAdapter
+    def bind(subscriber)
+      raise NotImplementedError
+    end
+
+    def unbind(subscriber)
+      raise NotImplementedError
+    end
+  end
+
+  module QueueAdapters
+  end
+end

data/lib/chasqui/queue_adapters/redis_queue_adapter.rb

@@ -0,0 +1,51 @@
+module Chasqui
+  module QueueAdapters
+    class RedisQueueAdapter
+      extend Forwardable
+      def_delegators :Chasqui, :redis
+
+      def bind(subscriber)
+        Chasqui::Worker.create subscriber
+
+        subscriber.channels.each do |channel|
+          redis.sadd key(channel), queue_description(subscriber)
+          worker_redis.sadd 'queues', subscriber.queue
+        end
+      end
+
+      def unbind(subscriber)
+        subscriber.channels.each do |channel|
+          redis.srem key(channel), queue_description(subscriber)
+        end
+      end
+
+      private
+
+      def key(channel)
+        "subscriptions:#{channel}"
+      end
+
+      def queue_description(subscriber)
+        queue_name = [worker_namespace, 'queue', subscriber.queue].compact.join(':')
+        "#{worker_backend}/Chasqui::Workers::#{subscriber.name}/#{queue_name}"
+      end
+
+      def worker_redis
+        case worker_backend
+        when :resque
+          Resque.redis
+        when :sidekiq
+          Sidekiq.redis { |r| r }
+        end
+      end
+
+      def worker_namespace
+        worker_redis.namespace if worker_redis.respond_to? :namespace
+      end
+
+      def worker_backend
+        Chasqui.config.worker_backend
+      end
+    end
+  end
+end

data/lib/chasqui/subscriber.rb

@@ -1,74 +1,81 @@
-require 'set'
-
 module Chasqui
+  module Subscriber
+    attr_reader :event
 
-  HandlerAlreadyRegistered = Class.new StandardError
+    def self.included(klass)
+      klass.extend Chasqui::Subscriber::ClassMethods
+    end
 
-  class Subscriber
-    attr_accessor :redis, :current_event
-    attr_reader :queue, :channel
+    def initialize(options={})
+      @event = options.fetch(:event)
 
-    def initialize(queue, channel)
-      @queue = queue
-      @channel = channel
+      @logger = options[:logger]
+      @redis = options[:redis]
     end
 
-    def on(event_name, &block)
-      pattern = pattern_for_event event_name
+    def redis
+      @redis ||= Chasqui.redis
+    end
 
-      if handler_patterns.include? pattern
-        raise HandlerAlreadyRegistered.new "handler already registered for event: #{event_name}"
-      else
-        handler_patterns << pattern
-        define_handler_method pattern, &block
-      end
+    def logger
+      @logger ||= Chasqui.logger
+    end
+
+    def perform(payload)
+      raise NotImplementedError
     end
 
-    def perform(redis_for_worker, event)
-      self.redis = redis_for_worker
-      self.current_event = event
+    class << self
+      attr_reader :subscribers
 
-      matching_handler_patterns_for(event['event']).each do |pattern|
-        call_handler pattern, *event['data']
+      def register_subscriber(klass)
+        @subscribers ||= Set.new
+        @subscribers << klass
+        Chasqui.register klass
       end
     end
 
-    def matching_handler_patterns_for(event_name)
-      handler_patterns.select do |pattern|
-        pattern =~ event_name
+    module ClassMethods
+      SubscriberConfig = Struct.new :channels, :queue
+
+      def subscriber_config
+        @subscriber_config ||= SubscriberConfig.new(
+          Chasqui.channel_prefix,
+          Chasqui.default_queue
+        )
       end
-    end
 
-    def call_handler(pattern, *args)
-      send "handler__#{pattern.to_s}", *args
-    end
+      def subscribe(args={})
+        queue = args.fetch :queue, Chasqui.default_queue
 
-    def evaluate(&block)
-      @self_before_instance_eval = eval "self", block.binding
-      instance_eval &block
-    end
+        subscriber_config.channels = prefixed_channels args
+        subscriber_config.queue = queue
 
-    private
+        Chasqui::Subscriber.register_subscriber self
+      end
 
-    def handler_patterns
-      @handler_patterns ||= Set.new
-    end
+      def channels
+        subscriber_config.channels
+      end
 
-    def method_missing(method, *args, &block)
-      if @self_before_instance_eval
-        @self_before_instance_eval.send method, *args, &block
-      else
-        super
+      def queue
+        subscriber_config.queue
       end
-    end
 
-    def pattern_for_event(event_name)
-      /\A#{event_name.to_s.downcase.gsub('*', '.*')}\z/
-    end
+      private
 
-    def define_handler_method(pattern, &block)
-      self.class.send :define_method, "handler__#{pattern.to_s}", &block
-    end
+      def prefixed_channels(args)
+        channel = args.fetch :channel, Chasqui.channel_prefix
+        prefix = args.fetch :prefix, Chasqui.channel_prefix
+
+        channels = channel.respond_to?(:each) ? channel : [channel]
 
+        if prefix
+          channels.map { |c| "#{prefix}.#{c}" }
+        else
+          channels
+        end
+      end
+    end
   end
 end

data/lib/chasqui/subscriptions.rb

@@ -0,0 +1,67 @@
+module Chasqui
+  class Subscriptions
+    attr_reader :queue_adapter
+
+    def initialize(queue_adapter)
+      @subscriptions = {}
+      @subscribers ||= {}
+      @queue_adapter = queue_adapter
+    end
+
+    def register(subscriber)
+      subscriber.channels.each do |channel|
+        register_one channel, subscriber
+      end
+    end
+
+    def unregister(subscriber)
+      subscriber.channels.each do |channel|
+        unregister_one channel, subscriber
+      end
+    end
+
+    def find(channel, queue)
+      @subscriptions[queue.to_s][channel.to_s].values
+    end
+
+    def subscribers
+      @subscribers.values
+    end
+
+    def subscribed?(subscriber)
+      @subscribers.key? subscriber.object_id
+    end
+
+    def autoregister!
+      Subscriber.subscribers.each { |s| register s }
+    end
+
+    private
+
+    def register_one(channel, subscriber)
+      q = subscriber.queue.to_s
+      c = channel.to_s
+
+      @subscriptions[q] ||= {}
+      @subscriptions[q][c] ||= {}
+      @subscriptions[q][c][subscriber.object_id] = subscriber
+
+      @subscribers[subscriber.object_id] = subscriber
+
+      queue_adapter.bind subscriber
+    end
+
+    def unregister_one(channel, subscriber)
+      q = subscriber.queue.to_s
+      c = channel.to_s
+
+      queue_adapter.unbind subscriber
+
+      if @subscriptions[q] && @subscriptions[q][c]
+        @subscriptions[q][c].delete subscriber.object_id
+      end
+
+      @subscribers.delete subscriber.object_id
+    end
+  end
+end

data/lib/chasqui/version.rb

@@ -1,3 +1,3 @@
 module Chasqui
-  VERSION = "0.9.3"
+  VERSION = '1.0.0-rc1'
 end

data/lib/chasqui/worker.rb

@@ -0,0 +1,81 @@
+module Chasqui
+  module Chasqui::Workers
+  end
+
+  class Worker
+    class << self
+
+      BACKENDS = {
+        resque: 'ResqueWorkerFactory',
+        sidekiq: 'SidekiqWorkerFactory'
+      }
+
+      def create(subscriber)
+        workers[subscriber.object_id] ||= create_worker(subscriber)
+      end
+
+      def workers
+        @workers ||= {}
+      end
+
+      private
+
+      def check_for_worker_backend
+        unless BACKENDS.keys.include? Chasqui.worker_backend
+          msg = "Chasqui.config.worker_backend must be one of #{BACKENDS.keys}"
+          raise ConfigurationError.new msg
+        end
+      end
+
+      def worker_factory
+        Chasqui.const_get BACKENDS[Chasqui.worker_backend]
+      end
+
+      def create_worker(subscriber)
+        check_for_worker_backend
+        worker = worker_factory.create subscriber
+        Chasqui::Workers.const_set subscriber.name, worker
+      end
+
+    end
+  end
+
+  class ResqueWorkerFactory
+    def self.create(subscriber)
+      Class.new do
+        @queue = subscriber.queue
+        @subscriber = subscriber
+
+        class << self
+          attr_reader :subscriber
+        end
+
+        def self.perform(event)
+          instance = @subscriber.new event: event, logger: Resque.logger
+          instance.perform event['payload']
+        end
+      end
+    end
+  end
+
+  class SidekiqWorkerFactory
+    def self.create(subscriber)
+      Class.new do
+        include Sidekiq::Worker
+        sidekiq_options 'queue' => 'foo-queue'
+
+        @subscriber = subscriber
+
+        class << self
+          attr_reader :subscriber
+        end
+
+        def perform(event)
+          instance = self.class.subscriber.new event: event, logger: logger
+          instance.perform event['payload']
+        end
+      end
+    end
+  end
+
+end

data/spec/integration/pubsub_examples.rb

@@ -1,31 +1,31 @@
 require 'spec_helper'
 
-shared_examples 'pubsub' do |namespace, start_workers_method|
+shared_examples 'pubsub' do |start_workers_method|
 
   def events_to_publish
     [
-      { event: 'user.signup',    data: ['Kelly'] },
-      { event: 'account.credit', data: [1337, 'Kelly'] },
-      { event: 'account.debit',  data: [10, 'Kelly'] },
-      { event: 'user.signup',    data: ['Travis'] },
-      { event: 'account.debit',  data: [9000, 'Kelly'] },
-      { event: 'user.cancel',    data: ['Kelly'] },
-      { event: 'account.credit', data: [42, 'Travis'] },
+      { channel: 'user.signup',    payload: ['Kelly'] },
+      { channel: 'account.credit', payload: [1337, 'Kelly'] },
+      { channel: 'account.debit',  payload: [10, 'Kelly'] },
+      { channel: 'user.signup',    payload: ['Travis'] },
+      { channel: 'account.debit',  payload: [9000, 'Kelly'] },
+      { channel: 'user.cancel',    payload: ['Kelly'] },
+      { channel: 'account.credit', payload: [42, 'Travis'] },
     ]
   end
 
   def expected_events
     {
       'app1' => [
-        { event: 'user.signup', data: ['Kelly'] },
-        { event: 'user.signup', data: ['Travis'] },
+        { channel: 'user.signup', payload: ['Kelly'] },
+        { channel: 'user.signup', payload: ['Travis'] },
       ],
       'app2' => [
-        { event: 'account.credit', data: [1337, 'Kelly'] },
-        { event: 'account.debit',  data: [10, 'Kelly'] },
-        { event: 'account.debit',  data: [9000, 'Kelly'] },
-        { event: 'user.cancel',    data: ['Kelly'] },
-        { event: 'account.credit', data: [42, 'Travis'] },
+        { channel: 'account.credit', payload: [1337, 'Kelly'] },
+        { channel: 'account.debit',  payload: [10, 'Kelly'] },
+        { channel: 'account.debit',  payload: [9000, 'Kelly'] },
+        { channel: 'user.cancel',    payload: ['Kelly'] },
+        { channel: 'account.credit', payload: [42, 'Travis'] },
       ],
     }
   end
@@ -37,7 +37,7 @@ shared_examples 'pubsub' do |namespace, start_workers_method|
     @redis.keys('*').each { |k| @redis.del k }
 
     Chasqui.configure do |c|
-      c.channel = 'integration'
+      c.channel_prefix = 'integration'
       c.redis = @redis_url
     end
 
@@ -56,17 +56,17 @@ shared_examples 'pubsub' do |namespace, start_workers_method|
 
   it 'works' do
     events_to_publish.each do |event|
-      Chasqui.publish event[:event], *event[:data]
+      Chasqui.publish event[:channel], *event[:payload]
     end
 
     begin
       Timeout::timeout(10) do
         expected_events.each do |subscriber_queue, events|
           events.each do |expected|
-            _, payload = @redis.blpop "#{namespace}:#{subscriber_queue}:event_log"
+            _, payload = Chasqui.redis.blpop "#{subscriber_queue}:event_log"
             actual = JSON.parse payload
-            expect(actual['event']).to eq(expected[:event])
-            expect(actual['data']).to eq(expected[:data])
+            expect(actual['channel']).to eq(expected[:channel])
+            expect(actual['payload']).to eq(expected[:payload])
           end
         end
       end

data/spec/integration/resque_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'integration/pubsub_examples'
 
 describe "resque integration", integration: true do
-  include_examples 'pubsub', :resque, :start_resque_workers
+  include_examples 'pubsub', :start_resque_workers
 
   def start_resque_workers
     @subscriber_queues.each do |queue|

data/spec/integration/setup/subscribers.rb

@@ -1,14 +1,30 @@
-def log_event subscriber, args
-  event = subscriber.current_event
-  payload = { event: event['event'], data: args }.to_json
-  subscriber.redis.rpush "#{subscriber.queue}:event_log", payload
+def log_event subscriber, payload
+  Chasqui.redis.rpush "#{subscriber.class.queue}:event_log", subscriber.event.to_json
 end
 
-Chasqui.subscribe channel: 'integration', queue: 'app1' do
-  on('user.signup') { |*args| log_event self, args }
+class UserSignupSubscriber
+  include Chasqui::Subscriber
+  subscribe channel: 'user.signup', queue: 'app1'
+
+  def perform(payload)
+    log_event self, payload
+  end
 end
 
-Chasqui.subscribe channel: 'integration', queue: 'app2' do
-  on('account.*')   { |*args| log_event self, args }
-  on('user.cancel') { |*args| log_event self, args }
+class AccountSubscriber
+  include Chasqui::Subscriber
+  subscribe channel: ['account.credit', 'account.debit'], queue: 'app2'
+
+  def perform(payload)
+    log_event self, payload
+  end
+end
+
+class UserCancelSubscriber
+  include Chasqui::Subscriber
+  subscribe channel: 'user.cancel', queue: 'app2'
+
+  def perform(payload)
+    log_event self, payload
+  end
 end