chasqui 1.0.0.pre.rc1 → 1.0.0

data/lib/chasqui/{queue_adapters → queue_adapter}/redis_queue_adapter.rb

@@ -1,22 +1,16 @@
 module Chasqui
-  module QueueAdapters
+  module QueueAdapter
     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
+        redis.sadd key(subscriber.channel), queue_description(subscriber)
+        worker_redis.sadd 'queues', subscriber.queue
       end
 
       def unbind(subscriber)
-        subscriber.channels.each do |channel|
-          redis.srem key(channel), queue_description(subscriber)
-        end
+        redis.srem key(subscriber.channel), queue_description(subscriber)
       end
 
       private
@@ -27,7 +21,7 @@ module Chasqui
 
       def queue_description(subscriber)
         queue_name = [worker_namespace, 'queue', subscriber.queue].compact.join(':')
-        "#{worker_backend}/Chasqui::Workers::#{subscriber.name}/#{queue_name}"
+        "#{worker_backend}/#{subscriber.worker.name}/#{queue_name}"
       end
 
       def worker_redis
@@ -35,7 +29,7 @@ module Chasqui
         when :resque
           Resque.redis
         when :sidekiq
-          Sidekiq.redis { |r| r }
+          ::Sidekiq.redis { |r| r }
         end
       end
 

data/lib/chasqui/subscriber.rb

@@ -1,81 +1,4 @@
 module Chasqui
-  module Subscriber
-    attr_reader :event
-
-    def self.included(klass)
-      klass.extend Chasqui::Subscriber::ClassMethods
-    end
-
-    def initialize(options={})
-      @event = options.fetch(:event)
-
-      @logger = options[:logger]
-      @redis = options[:redis]
-    end
-
-    def redis
-      @redis ||= Chasqui.redis
-    end
-
-    def logger
-      @logger ||= Chasqui.logger
-    end
-
-    def perform(payload)
-      raise NotImplementedError
-    end
-
-    class << self
-      attr_reader :subscribers
-
-      def register_subscriber(klass)
-        @subscribers ||= Set.new
-        @subscribers << klass
-        Chasqui.register klass
-      end
-    end
-
-    module ClassMethods
-      SubscriberConfig = Struct.new :channels, :queue
-
-      def subscriber_config
-        @subscriber_config ||= SubscriberConfig.new(
-          Chasqui.channel_prefix,
-          Chasqui.default_queue
-        )
-      end
-
-      def subscribe(args={})
-        queue = args.fetch :queue, Chasqui.default_queue
-
-        subscriber_config.channels = prefixed_channels args
-        subscriber_config.queue = queue
-
-        Chasqui::Subscriber.register_subscriber self
-      end
-
-      def channels
-        subscriber_config.channels
-      end
-
-      def queue
-        subscriber_config.queue
-      end
-
-      private
-
-      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
+  class Subscriber < Struct.new(:channel, :queue, :worker)
   end
 end

data/lib/chasqui/subscription_builder.rb

@@ -0,0 +1,135 @@
+module Chasqui
+  # A namespace for defining dynamically generated worker classes for callable
+  # objects.
+  module Workers
+  end
+
+  # Provides the context used in {Chasqui.subscribe} to bind workers to
+  # channels via the {#on} method.
+  class SubscriptionBuilder
+    # The collection of currently registered subscriptions.
+    # @return [Chasqui::Subscriptions]
+    attr_reader :subscriptions
+
+    # Default options for calls to {#on}.
+    # @return [Hash]
+    attr_reader :default_options
+
+    # @visibility private
+    # You should not instantiate this class directly. Instead use the
+    # {Chasqui.subscribe} method to create a subscription builder context.
+    def initialize(subscriptions, options={})
+      @subscriptions = subscriptions
+      @default_options = options
+    end
+
+    # Bind a worker to a channel.
+    #
+    # The broker will place jobs on the worker's queue for each event published
+    # to the given channel.
+    #
+    # @param channel [String] the channel name
+    # @param worker_or_proc [#perform,.perform,#call] a Sidekiq Worker
+    #   class, Resque worker class, or proc to handle events published to
+    #   channel. If a proc is used as a worker, +#on+ will define a new worker
+    #   class that delegates +#perform+ to +proc#call+.
+    # @param options [Hash]
+    #
+    # @option options [String] :queue the worker queue.
+    #   When given, this option will override the queue defined by the worker
+    #   class. This option is recommended when using a proc as a worker.
+    # @option options [String] :queue_prefix prefix for queue.
+    #   When supplied, the value of this option is prepended to the queue name.
+    #   Use this option to namespace your queues in order to prevent collisions
+    #   with queues from other applicaitons sharing the same Redis database.
+    def on(channel, worker_or_proc, options={})
+      options = default_options.merge(options)
+      worker = build_worker(channel, worker_or_proc, options)
+
+      queue = full_queue_name(worker, options)
+      set_queue_name(worker, queue)
+      
+      subscriptions.register Chasqui::Subscriber.new(channel, queue, worker)
+    end
+
+    # @visibility private
+    # Instantiate a new subscription builder suitable for the configured
+    # {Chasqui.worker_backend worker_backend}.
+    def self.builder(subscriptions, options={})
+      builder_for_backend.new subscriptions, options
+    end
+
+    protected
+
+    def get_queue_name(worker)
+      raise NotImplementedError
+    end
+
+    def set_queue_name(worker, queue)
+      raise NotImplementedError
+    end
+
+    def define_worker_class(channel, callable, options)
+      raise NotImplementedError
+    end
+
+    def redefine_perform_method(worker, &block)
+      raise NotImplementedError
+    end
+
+    private
+
+    def self.builder_for_backend
+      case Chasqui.worker_backend
+      when :resque
+        ResqueSubscriptionBuilder
+      when :sidekiq
+        SidekiqSubscriptionBuilder
+      else
+        msg = <<-ERR.gsub(/^ {8}/, '')
+        No worker backend configured.
+
+            # To configure a worker backend:
+            Chasqui.config do |c|
+              c.worker_backend = :resque # or :sidekiq
+            end
+        ERR
+        raise Chasqui::ConfigurationError.new msg
+      end
+    end
+
+    def full_queue_name(worker, options={})
+      queue = options.fetch :queue, get_queue_name(worker)
+      prefix = options[:queue_prefix]
+
+      prefix ? "#{prefix}:#{queue}" : queue
+    end
+
+    def build_worker(channel, worker_or_proc, options={})
+      worker = worker_or_proc
+
+      if worker.respond_to? :call
+        worker = define_worker_class(channel, worker_or_proc, options)
+        Chasqui::Workers.const_set worker_class_name(channel), worker
+      end
+
+      redefine_perform_method(worker) do |klass|
+        klass.send :define_method, :perform_with_event do |event|
+          perform_without_event event, *event['payload']
+        end
+
+        klass.send :alias_method, :perform_without_event, :perform
+        klass.send :alias_method, :perform, :perform_with_event
+      end
+
+      worker
+    end
+
+    def worker_class_name(channel)
+      segments = channel.split(/[^\w]/).map(&:downcase)
+      name = segments.each { |w| w[0] = w[0].upcase }.join
+
+      "#{name}Worker".freeze
+    end
+  end
+end

data/lib/chasqui/subscription_builder/resque_subscription_builder.rb

@@ -0,0 +1,31 @@
+module Chasqui
+  class ResqueSubscriptionBuilder < SubscriptionBuilder
+    protected
+
+    def get_queue_name(worker)
+      worker.instance_variable_get :@queue
+    end
+
+    def set_queue_name(worker, queue)
+      worker.instance_variable_set :@queue, queue
+    end
+
+    def define_worker_class(channel, callable, options)
+      Class.new do
+        @queue = Chasqui.default_queue
+        define_singleton_method :perform, callable
+      end
+    end
+
+    def redefine_perform_method(worker)
+      return if worker.respond_to?(:perform_with_event)
+
+      worker.instance_eval do
+        class << self
+          yield self
+        end
+      end
+    end
+
+  end
+end

data/lib/chasqui/subscription_builder/sidekiq_subscription_builder.rb

@@ -0,0 +1,27 @@
+module Chasqui
+  class SidekiqSubscriptionBuilder < SubscriptionBuilder
+    protected
+
+    def get_queue_name(worker)
+      worker.sidekiq_options['queue']
+    end
+
+    def set_queue_name(worker, queue)
+      worker.sidekiq_options queue: queue
+    end
+
+    def define_worker_class(channel, callable, options)
+      Class.new do
+        include ::Sidekiq::Worker
+        sidekiq_options queue: Chasqui.default_queue
+        define_method :perform, callable
+      end
+    end
+
+    def redefine_perform_method(worker, &block)
+      return if worker.instance_methods.include?(:perform_with_event)
+
+      yield worker
+    end
+  end
+end

data/lib/chasqui/subscriptions.rb

@@ -9,15 +9,29 @@ module Chasqui
     end
 
     def register(subscriber)
-      subscriber.channels.each do |channel|
-        register_one channel, subscriber
-      end
+      queue = subscriber.queue.to_s
+      channel = subscriber.channel.to_s
+
+      @subscriptions[queue] ||= {}
+      @subscriptions[queue][channel] ||= {}
+      @subscriptions[queue][channel][subscriber.worker] = subscriber
+
+      @subscribers[subscriber.worker] = subscriber
+
+      queue_adapter.bind subscriber
     end
 
     def unregister(subscriber)
-      subscriber.channels.each do |channel|
-        unregister_one channel, subscriber
+      queue = subscriber.queue.to_s
+      channel = subscriber.channel.to_s
+
+      queue_adapter.unbind subscriber
+
+      if @subscriptions[queue] && @subscriptions[queue][channel]
+        @subscriptions[queue][channel].delete subscriber.worker
       end
+
+      @subscribers.delete subscriber.worker
     end
 
     def find(channel, queue)
@@ -29,39 +43,7 @@ module Chasqui
     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
+      @subscribers.key? subscriber.worker
     end
   end
 end

data/lib/chasqui/version.rb

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

data/spec/integration/pubsub_examples.rb

@@ -67,6 +67,7 @@ shared_examples 'pubsub' do |start_workers_method|
             actual = JSON.parse payload
             expect(actual['channel']).to eq(expected[:channel])
             expect(actual['payload']).to eq(expected[:payload])
+            expect(actual['payload']).to eq(actual['worker_args'])
           end
         end
       end

data/spec/integration/setup/resque.rb

@@ -4,4 +4,41 @@ require 'resque'
 Resque.redis = ENV['REDIS_URL'] if ENV['REDIS_URL']
 Resque.redis.namespace = :resque
 
-require './spec/integration/setup/subscribers'
+def log_event(worker, event, *args)
+  queue = worker.instance_variable_get(:@queue)
+  event['worker_args'] = args
+  event['class'] = worker.name
+
+  Chasqui.redis.rpush "#{queue}:event_log", event.to_json
+end
+
+class UserSignupWorker
+  @queue = 'app1'
+
+  def self.perform(event, *args)
+    log_event self, event, *args
+  end
+end
+
+class TransactionWorker
+  @queue = 'app2'
+
+  def self.perform(event, *args)
+    log_event self, event, *args
+  end
+end
+
+class UserCancelWorker
+  @queue = 'app2'
+
+  def self.perform(event, *args)
+    log_event self, event, *args
+  end
+end
+
+Chasqui.subscribe do
+  on 'user.signup', UserSignupWorker
+  on 'user.cancel', UserCancelWorker
+  on 'account.credit', TransactionWorker
+  on 'account.debit', TransactionWorker
+end