queueing_rabbit 0.1.3 → 0.2.0

data/lib/queueing_rabbit/client/amqp.rb

@@ -6,12 +6,11 @@ module QueueingRabbit
 
     class AMQP
 
-      include QueueingRabbit::Serializer
       include QueueingRabbit::Logging
       extend  QueueingRabbit::Logging
       extend  QueueingRabbit::Client::Callbacks
 
-      attr_reader :connection, :exchange_name, :exchange_options
+      attr_reader :connection
 
       define_callback :on_tcp_failure do |_|
         fatal "unable to establish TCP connection to broker"
@@ -39,24 +38,33 @@ module QueueingRabbit
       end
 
       def self.connect
-        self.run_event_machine
+        self.ensure_event_machine_is_running
 
-        self.new(::AMQP.connect(QueueingRabbit.amqp_uri, connection_options),
-                 QueueingRabbit.amqp_exchange_name,
-                 QueueingRabbit.amqp_exchange_options)
+        self.new(::AMQP.connect(QueueingRabbit.amqp_uri, connection_options))
       end
 
-      def self.run_event_machine
-        return if EM.reactor_running?
+      def self.ensure_event_machine_is_running
+        run_event_machine unless EM.reactor_running?
+      end
 
+      def self.run_event_machine
         @event_machine_thread = Thread.new do
           EM.run do
             QueueingRabbit.trigger_event(:event_machine_started)
           end
         end
 
-        # Block the control process while EM is starting up
-        sleep 0.5
+        wait_for_event_machine_to_start
+      end
+
+      def self.wait_for_event_machine_to_start
+        Timeout.timeout(5) do
+          sleep 0.5 until EM.reactor_running?
+        end
+      rescue Timeout::Error => e
+        description = "wait timeout exceeded while starting up EventMachine"
+        fatal description
+        raise QueueingRabbitError.new(description)
       end
 
       def self.join_event_machine_thread
@@ -74,54 +82,54 @@ module QueueingRabbit
       end
 
       def define_queue(channel, queue_name, options={})
-        routing_keys = [*options.delete(:routing_keys)] + [queue_name]
-
         channel.queue(queue_name.to_s, options) do |queue|
-          routing_keys.each do |key|
-            queue.bind(exchange(channel), :routing_key => key.to_s)
-          end
+          yield queue if block_given?
         end
       end
 
-      def listen_queue(channel, queue_name, options={}, &block)
-        define_queue(channel, queue_name, options).
-            subscribe(:ack => true) do |metadata, payload|
-          begin
-            process_message(deserialize(payload), &block)
-            metadata.ack
-          rescue JSON::JSONError => e
-            error "JSON parser error occured: #{e.message}"
-            debug e
-          end
+      def bind_queue(queue, exchange, options = {})
+        queue.bind(exchange, options)
+      end
+
+      def listen_queue(queue, options = {}, &block)
+        queue.subscribe(options) do |metadata, payload|
+          process_message(payload, metadata, &block)
         end
       end
 
-      def process_message(arguments)
+      def process_message(payload, metadata)
         begin
-          yield arguments
+          yield payload, metadata
         rescue => e
           error "unexpected error #{e.class} occured: #{e.message}"
           debug e
         end
       end
 
-      def open_channel(options={})
-        ::AMQP::Channel.new(connection,
-                          ::AMQP::Channel.next_channel_id,
-                          options) do |c, open_ok|
+      def open_channel(options = {})
+        channel_id = ::AMQP::Channel.next_channel_id
+        ::AMQP::Channel.new(connection, channel_id, options) do |c, open_ok|
+          c.confirm_select if !!options[:use_publisher_confirms]
           c.on_error(&self.class.callback(:on_channel_error))
           yield c, open_ok
         end
       end
 
-      def define_exchange(channel, options={})
-        channel.direct(exchange_name, exchange_options.merge(options))
+      def define_exchange(channel, name = '', options = {})
+        type = options.delete(:type)
+        with_exchange = Proc.new do |exchange, _|
+          yield exchange if block_given?
+        end
+
+        if type && type != :default
+          channel.send(type.to_sym, name, options, &with_exchange)
+        else
+          channel.default_exchange.tap(&with_exchange)
+        end
       end
-      alias_method :exchange, :define_exchange
 
-      def enqueue(channel, routing_key, payload)
-        exchange(channel).publish(serialize(payload), :key => routing_key.to_s,
-                                                      :persistent => true)
+      def enqueue(exchange, payload, options = {})
+        exchange.publish(payload, options)
       end
       alias_method :publish, :enqueue
 
@@ -136,10 +144,8 @@ module QueueingRabbit
         connection.on_recovery(&self.class.callback(:on_tcp_recovery))
       end
 
-      def initialize(connection, exchange_name, exchange_options = {})
+      def initialize(connection)
         @connection = connection
-        @exchange_name = exchange_name
-        @exchange_options = exchange_options
 
         setup_callbacks
       end

data/lib/queueing_rabbit/client/bunny.rb

@@ -6,44 +6,44 @@ module QueueingRabbit
 
     class Bunny
 
-      include QueueingRabbit::Serializer
-
-      attr_reader :connection, :exchange_name, :exchange_options
+      attr_reader :connection
 
       def self.connect
-        self.new(::Bunny.new(QueueingRabbit.amqp_uri),
-                 QueueingRabbit.amqp_exchange_name,
-                 QueueingRabbit.amqp_exchange_options)
+        self.new(::Bunny.new(QueueingRabbit.amqp_uri))
       end
 
       def open_channel(options = {})
         ch = connection.create_channel
+        ch.confirm_select if !!options[:use_publisher_confirms]
         yield ch, nil
         ch
       end
 
       def define_queue(channel, name, options = {})
-        routing_keys = ([*options.delete(:routing_keys)] + [name]).compact
-
         queue = channel.queue(name.to_s, options)
-
-        routing_keys.each do |key|
-          queue.bind(exchange(channel), :routing_key => key.to_s)
-        end
-
+        yield queue if block_given?
         queue
       end
 
-      def enqueue(channel, routing_key, payload)
-        exchange(channel).publish(serialize(payload), :key => routing_key.to_s,
-                                                      :persistent => true)
+      def bind_queue(queue, exchange, options = {})
+        queue.bind(exchange, options)
+      end
+
+      def enqueue(exchange, payload, options = {})
+        exchange.publish(payload, options)
       end
       alias_method :publish, :enqueue
 
-      def define_exchange(channel, options={})
-        channel.direct(exchange_name, exchange_options.merge(options))
+      def define_exchange(channel = nil, name = '', options = {})
+        type = options.delete(:type)
+
+        exchange = type ? channel.send(type.to_sym, name, options) :
+                          channel.default_exchange
+
+        yield exchange if block_given?
+
+        exchange
       end
-      alias_method :exchange, :define_exchange
 
       def queue_size(queue)
         queue.status[:message_count]
@@ -51,11 +51,8 @@ module QueueingRabbit
 
     private
 
-      def initialize(connection, exchange_name, exchange_options)
+      def initialize(connection)
         @connection = connection
-        @exchange_name = exchange_name
-        @exchange_options = exchange_options
-
         @connection.start
       end
 

data/lib/queueing_rabbit/extensions/direct_exchange.rb

@@ -0,0 +1,26 @@
+module QueueingRabbit
+
+  module JobExtensions
+
+    module DirectExchange
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def exchange_options
+          @exchange_options ||= {}
+          @exchange_options.update(:type => :direct)
+        end
+
+        def binding_options
+          @binding_options || {:routing_key => queue_name.to_s}
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/queueing_rabbit/extensions/new_relic.rb

@@ -1,18 +1,33 @@
 module QueueingRabbit
 
-  module Extensions
+  module JobExtensions
 
     module NewRelic
 
-      def self.included(mod)
-        mod.class_eval do |klass|
-          class << klass
+      def self.included(klass)
+        if klass.respond_to?(:perform)
+          add_for_class_method(klass)
+        else
+          add_for_instance_method(klass)
+        end
+      end
+
+      def self.add_for_class_method(klass)
+        klass.class_eval do |k|
+          class << k
             include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
             add_transaction_tracer :perform, :category => :task
           end
         end
       end
 
+      def self.add_for_instance_method(klass)
+        klass.class_eval do |k|
+          include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+          add_transaction_tracer :perform, :category => :task
+        end
+      end
+
     end
 
   end

data/lib/queueing_rabbit/extensions/retryable.rb

@@ -0,0 +1,22 @@
+module QueueingRabbit
+
+  module JobExtensions
+
+    module Retryable
+
+      def retries
+        headers['qr_retries'].to_i
+      end
+
+      def retry_upto(max_retries)
+        if retries < max_retries
+          updated_headers = headers.update('qr_retries' => retries + 1)
+          self.class.enqueue(payload, :headers => updated_headers)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/queueing_rabbit/job.rb

@@ -1,5 +1,15 @@
 module QueueingRabbit
+
   module Job
+
+    def queue(*args)
+      if args.first.kind_of?(Hash)
+        @queue_options = args.first
+      else
+        @queue_name, @queue_options = args
+      end
+    end
+
     def queue_name
       @queue_name ||= self.name.split('::')[-1]
     end
@@ -8,25 +18,60 @@ module QueueingRabbit
       @queue_options ||= {}
     end
 
-    def queue(name, options = {})
-      @queue_name = name
-      @queue_options = options
-    end
-
     def queue_size
       QueueingRabbit.queue_size(self)
     end
 
+    def channel(options={})
+      @channel_options = options
+    end
+
     def channel_options
       @channel_options ||= {}
     end
 
-    def channel(options={})
-      @channel_options = options
+    def exchange(name, options = {})
+      @exchange_name = name
+      @exchange_options = options
     end
-  end
 
-  class AbstractJob
-    extend Job
+    def exchange_name
+      @exchange_name
+    end
+
+    def exchange_options
+      @exchange_options ||= {}
+    end
+
+    def bind(options = {})
+      @binding_options = options
+    end
+
+    def binding_options
+      @binding_options || nil
+    end
+
+    def bind_queue?
+      exchange_options[:type] && exchange_options[:type] != :default && binding_options
+    end
+
+    def listening_options
+      @listening_options || {}
+    end
+
+    def listen(options = {})
+      @listening_options = options
+    end
+
+    def publishing_defaults(options = {})
+      @publishing_defaults ||= options.merge(:routing_key => queue_name.to_s)
+    end
+
+    def enqueue(payload, options = {})
+      QueueingRabbit.enqueue(self, payload, publishing_defaults.merge(options))
+    end
+    alias_method :publish, :enqueue
+
   end
-end
+
+end

data/lib/queueing_rabbit/jobs/abstract_job.rb

@@ -0,0 +1,27 @@
+module QueueingRabbit
+
+  class AbstractJob
+
+    extend Job
+
+    attr_reader :payload, :metadata
+
+    def initialize(payload, metadata)
+      @payload = payload
+      @metadata = metadata
+    end
+
+    def acknowledge
+      metadata.ack
+    end
+
+    def headers
+      metadata.headers || {}
+    end
+
+    def perform
+    end
+
+  end
+
+end

data/lib/queueing_rabbit/jobs/json_job.rb

@@ -0,0 +1,19 @@
+module QueueingRabbit
+
+  class JSONJob < AbstractJob
+
+    extend QueueingRabbit::Serializer
+
+    alias_method :arguments, :payload
+
+    def self.enqueue(payload, metadata = {})
+      super serialize(payload), metadata
+    end
+
+    def initialize(payload, metadata = {})
+      super self.class.deserialize(payload), metadata
+    end
+
+  end
+
+end