rabbit_jobs 0.11.5 → 0.12.0

data/lib/rabbit_jobs/main_loop.rb

@@ -1,6 +1,17 @@
-# -*- encoding : utf-8 -*-
 module RabbitJobs
+  # Main process loop.
   module MainLoop
+    def startup
+      $stdout.sync = true
+
+      @shutdown = false
+
+      Signal.trap('TERM') { shutdown }
+      Signal.trap('INT')  { shutdown! }
+
+      true
+    end
+
     def shutdown
       @shutdown = true
     end
@@ -9,36 +20,26 @@ module RabbitJobs
       shutdown
     end
 
-    def main_loop(time)
+    def main_loop
       loop do
-        sleep 1
-        if time > 0
-          time -= 1
-          if time == 0
-            shutdown
-          end
-        end
+        sleep 0.5
+        next unless @shutdown
 
-        if @shutdown
-          RabbitJobs.logger.info "Stopping."
-          if defined?(amqp_connection) # in worker only
-            amqp_connection.stop
-            amqp_channel.work_pool.join
-          end
-          yield if block_given?
-          return true
+        RabbitJobs.logger.info 'Stopping.'
+        if defined?(amqp_connection) # in worker only
+          amqp_cleanup
         end
+        yield if block_given?
+        return true
       end
     end
 
     def log_daemon_error(error)
-      if RabbitJobs.logger
-        begin
-          RabbitJobs.logger.fatal error
-        ensure
-          abort(error.message)
-        end
-      end
+      return unless RabbitJobs.logger
+
+      RabbitJobs.logger.fatal error
+    ensure
+      abort(error.message)
     end
   end
 end

data/lib/rabbit_jobs/publisher.rb

@@ -3,34 +3,36 @@ require 'rabbit_jobs/publisher/test'
 require 'rabbit_jobs/publisher/sync'
 
 module RabbitJobs
+  # Interface for publishing messages to amqp queues or testing queues.
   class Publisher
     class << self
       def mode
-        publisher_type.class_name.underscore
+        publisher_instance.class_name.underscore
       end
 
+      # Allows to switch publisher implementations.
+      # You can use RJ.publisher.mode = :test in testing environment.
       def mode=(value)
-        @publisher_type = case value.to_s
-        when 'amqp'
-          Amqp
-        when 'test'
-          Test
-        when 'sync'
-          Sync
-        else
-          raise ArgumentError.new("value must be :amqp or :test. Passed: #{value.inspect}")
-        end
+        @publisher_instance = case value.to_s
+                              when 'amqp'
+                                Amqp
+                              when 'test'
+                                Test
+                              when 'sync'
+                                Sync
+                              else
+                                fail ArgumentError, "value must be :amqp, :sync or :test. Passed: #{value.inspect}"
+                              end
       end
 
-      %i(cleanup publish_to direct_publish_to purge_queue).each do |api_method|
-        delegate api_method, to: :publisher_type
-      end
+      delegate :cleanup, :publish_to, :direct_publish_to, :purge_queue, :queue_status, to: :publisher_instance
 
       private
 
-      def publisher_type
-        @publisher_type || Amqp
+      # Default publisher type is Amqp.
+      def publisher_instance
+        @publisher_instance || Amqp
       end
     end
   end
-end
+end

data/lib/rabbit_jobs/publisher/amqp.rb

@@ -1,75 +1,72 @@
 require 'rabbit_jobs/publisher/base'
+require 'rabbit_jobs/amqp_transport'
 
 module RabbitJobs
   class Publisher
+    # AMQP publisher implementation.
     class Amqp < Base
       class << self
+        delegate :amqp_cleanup, :amqp_connection, :publisher_channel, to: RabbitJobs::AmqpTransport
 
         def cleanup
-          conn = Thread.current[:rj_publisher_connection]
-          conn.close if conn && conn.status != :not_connected
-          Thread.current[:rj_publisher_connection] = nil
+          amqp_cleanup
         end
 
         def publish_to(routing_key, klass, *params)
-          raise ArgumentError.new("klass=#{klass.inspect}") unless klass.is_a?(Class) || klass.is_a?(String)
-          routing_key = routing_key.to_sym unless routing_key.is_a?(Symbol)
-          raise ArgumentError.new("routing_key=#{routing_key}") unless RabbitJobs.config[:queues][routing_key]
+          check_amqp_publishing_params(routing_key, klass)
 
           payload = Job.serialize(klass, *params)
-          direct_publish_to(routing_key, payload)
+          direct_publish_to(routing_key.to_sym, payload)
         end
 
         def direct_publish_to(routing_key, payload, ex = {})
-          ex = {name: ex.to_s} unless ex.is_a?(Hash)
-          begin
-            exchange_opts = Configuration::DEFAULT_MESSAGE_PARAMS.merge(ex || {})
-            exchange_name = exchange_opts.delete(:name).to_s
-
-            exchange = connection.default_channel.exchange(exchange_name, passive: true)
-            exchange.on_return do |basic_deliver, properties, payload|
-              RJ.logger.error full_message: caller.join("\r\n"),
-                short_message: "AMQP ERROR: (#{basic_deliver[:reply_code]}) #{basic_deliver[:reply_text].to_s}. exchange: #{basic_deliver[:exchange]}, key: #{basic_deliver[:routing_key]}.",
-                _basic_deliver: basic_deliver.inspect, _properties: properties.inspect, _payload: payload.inspect
-              true
-            end
-
-            unless connection.default_channel.basic_publish(payload, exchange_name, routing_key, exchange_opts).connection.connected?
-              raise "Disconnected from #{RJ.config.server}. Connection status: #{connection.try(:status).inspect}"
-            end
-          rescue
-            RabbitJobs.logger.error $!.message
-            raise $!
-          end
+          exchange_name, exchange_opts = build_exchange(ex)
+          publisher_channel.basic_publish(payload, exchange_name, routing_key, exchange_opts)
 
+          fail "Disconnected from #{RJ.config.server}." unless amqp_connection.connected?
           true
+        rescue
+          RabbitJobs.logger.error $!.message
+          raise $!
         end
 
         def purge_queue(*routing_keys)
-          raise ArgumentError unless routing_keys.present?
+          fail ArgumentError unless routing_keys.present?
 
-          messages_count = 0
           routing_keys.map(&:to_sym).each do |routing_key|
-            queue = connection.default_channel.queue(routing_key, RabbitJobs.config[:queues][routing_key])
-            messages_count += queue.status[:message_count].to_i
-            connection.default_channel.queue_purge(routing_key)
+            publisher_channel.queue_purge(routing_key)
           end
+        end
 
-          messages_count
+        def queue_status(routing_key)
+          check_queue_status_params(routing_key)
+          publisher_channel.queue(routing_key, RabbitJobs.config[:queues][routing_key.to_sym]).status
         end
 
         private
 
-        def settings
-          Thread.current[:rj_publisher] ||= {}
+        def build_exchange(ex)
+          ex = { name: ex.to_s } unless ex.is_a?(Hash)
+          exchange_opts = Configuration::DEFAULT_MESSAGE_PARAMS.merge(ex || {})
+          exchange_name = exchange_opts.delete(:name).to_s
+
+          exchange = publisher_channel.exchange(exchange_name, passive: true)
+          exchange_on_return_policy(exchange)
+          [exchange_name, exchange_opts]
         end
 
-        def connection
-          unless settings[:connection]
-            settings[:connection] = Bunny.new(RabbitJobs.config.server,
-              properties: Bunny::Session::DEFAULT_CLIENT_PROPERTIES.merge(product: "rj_scheduler #{Process.pid}")).start
+        def exchange_on_return_policy(exchange)
+          exchange.on_return do |basic_deliver, properties, returned_payload|
+            RJ.logger.error full_message: caller.join("\r\n"),
+                            short_message: "AMQP ERROR: (#{basic_deliver[:reply_code]}) " \
+                                           "#{basic_deliver[:reply_text]}. " \
+                                           "exchange: #{basic_deliver[:exchange]}, " \
+                                           "key: #{basic_deliver[:routing_key]}.",
+                            _basic_deliver: basic_deliver.inspect,
+                            _properties: properties.inspect,
+                            _payload: returned_payload.inspect
+            true
           end
-          settings[:connection]
         end
       end
     end

data/lib/rabbit_jobs/publisher/base.rb

@@ -1,23 +1,41 @@
 module RabbitJobs
   class Publisher
+    # Abstract publisher.
     class Base
       class << self
         def cleanup
-          raise NotImplementedError
+          fail NotImplementedError
         end
 
-        def publish_to(routing_key, klass, *params)
-          raise NotImplementedError
+        def publish_to(_routing_key, _klass, *_params)
+          fail NotImplementedError
         end
 
-        def direct_publish_to(routing_key, payload, ex = {})
-          raise NotImplementedError
+        def direct_publish_to(_routing_key, _payload, _ex = {})
+          fail NotImplementedError
         end
 
-        def purge_queue(*routing_keys)
-          raise NotImplementedError
+        def purge_queue(*_routing_keys)
+          fail NotImplementedError
+        end
+
+        def queue_status(_routing_key)
+          fail NotImplementedError
+        end
+
+        protected
+
+        def check_amqp_publishing_params(routing_key, klass)
+          fail ArgumentError, "klass=#{klass.inspect}" unless klass.is_a?(Class) || klass.is_a?(String)
+          routing_key = routing_key.to_sym unless routing_key.is_a?(Symbol)
+          fail ArgumentError, "routing_key=#{routing_key}" unless RabbitJobs.config[:queues][routing_key]
+        end
+
+        def check_queue_status_params(routing_key)
+          fail ArgumentError, 'routing_key is blank' if routing_key.blank?
+          fail ArgumentError, "Unknown queue: #{routing_key}" unless RJ.config.queue?(routing_key)
         end
       end
     end
   end
-end
+end

data/lib/rabbit_jobs/publisher/sync.rb

@@ -2,21 +2,28 @@ require 'rabbit_jobs/publisher/base'
 
 module RabbitJobs
   class Publisher
+    # Synchronous publisher.
+    # Calls Job#perform with no RabbitMQ interaction.
     class Sync < Base
       class << self
-
         def cleanup
         end
 
         def publish_to(routing_key, klass, *params)
-          raise ArgumentError.new("klass=#{klass.inspect}") unless klass.is_a?(Class) || klass.is_a?(String)
+          fail ArgumentError, "klass=#{klass.inspect}" unless klass.is_a?(Class) || klass.is_a?(String)
           routing_key = routing_key.to_sym unless routing_key.is_a?(Symbol)
-          raise ArgumentError.new("routing_key=#{routing_key}") unless RabbitJobs.config[:queues][routing_key]
+          fail ArgumentError, "routing_key=#{routing_key}" unless RabbitJobs.config[:queues][routing_key]
 
           klass.perform(*params)
         end
 
-        def purge_queue(*routing_keys)
+        def purge_queue(*_routing_keys)
+          fail ArgumentError unless routing_keys.present?
+        end
+
+        def queue_status(routing_key)
+          check_queue_status_params(routing_key)
+          { message_count: 0, consumer_count: 0 }
         end
       end
     end

data/lib/rabbit_jobs/publisher/test.rb

@@ -2,20 +2,19 @@ require 'rabbit_jobs/publisher/base'
 
 module RabbitJobs
   class Publisher
+    # Publisher for testing.
+    # Stores AMQP messages to array.
     class Test < Base
       class << self
-
         def cleanup
           messages.clear
         end
 
         def publish_to(routing_key, klass, *params)
-          raise ArgumentError.new("klass=#{klass.inspect}") unless klass.is_a?(Class) || klass.is_a?(String)
-          routing_key = routing_key.to_sym unless routing_key.is_a?(Symbol)
-          raise ArgumentError.new("routing_key=#{routing_key}") unless RabbitJobs.config[:queues][routing_key]
+          check_amqp_publishing_params(routing_key, klass)
 
           payload = Job.serialize(klass, *params)
-          direct_publish_to(routing_key, payload)
+          direct_publish_to(routing_key.to_sym, payload)
         end
 
         def direct_publish_to(routing_key, payload, ex = {})
@@ -25,11 +24,13 @@ module RabbitJobs
         end
 
         def purge_queue(*routing_keys)
-          raise ArgumentError unless routing_keys.present?
-
-          ret = messages.count
+          fail ArgumentError unless routing_keys.present?
           messages.clear
-          ret
+        end
+
+        def queue_status(routing_key)
+          check_queue_status_params(routing_key)
+          { message_count: messages.count, consumer_count: 0 }
         end
 
         private

data/lib/rabbit_jobs/scheduler.rb

@@ -1,5 +1,5 @@
-# -*- encoding : utf-8 -*-
 module RabbitJobs
+  # Scheduler daemon.
   class Scheduler
     include MainLoop
 
@@ -10,21 +10,12 @@ module RabbitJobs
       @schedule = HashWithIndifferentAccess.new(value)
     end
 
-    def load_default_schedule
-      if defined?(Rails)
-        file = Rails.root.join('config/schedule.yml')
-        if file.file?
-          @schedule = HashWithIndifferentAccess.new(YAML.load_file(file))
-        end
-      end
-    end
-
     # Pulls the schedule from Resque.schedule and loads it into the
     # rufus scheduler instance
     def load_schedule!
       @schedule ||= load_default_schedule
 
-      raise "You should setup a schedule or place it in config/schedule.yml" unless schedule
+      fail 'You should setup a schedule or place it in config/schedule.yml' unless schedule
 
       schedule.each do |name, config|
         # If rails_env is set in the config, enforce ENV['RAILS_ENV'] as
@@ -39,7 +30,9 @@ module RabbitJobs
 
     # Returns true if the given schedule config hash matches the current ENV['RAILS_ENV']
     def rails_env_matches?(config)
-      config['rails_env'] && ENV['RAILS_ENV'] && config['rails_env'].gsub(/\s/,'').split(',').include?(ENV['RAILS_ENV'])
+      config['rails_env'] &&
+        ENV['RAILS_ENV'] &&
+        config['rails_env'].gsub(/\s/, '').split(',').include?(ENV['RAILS_ENV'])
     end
 
     # Publish a job based on a config hash
@@ -68,17 +61,17 @@ module RabbitJobs
     end
 
     # Subscribes to channel and working on jobs
-    def work(time = 0)
+    def work
       begin
         return false unless startup
 
-        $0 = self.process_name || "rj_scheduler"
+        $0 = process_name || 'rj_scheduler'
 
-        RabbitJobs.logger.info "Started."
+        RabbitJobs.logger.info 'Started.'
 
         load_schedule!
 
-        return main_loop(time)
+        return main_loop
       rescue
         log_daemon_error($!)
       end
@@ -86,33 +79,26 @@ module RabbitJobs
       true
     end
 
-    def startup
-      # Fix buffering so we can `rake rj:work > resque.log` and
-      # get output from the child in there.
-      $stdout.sync = true
-
-      @shutdown = false
-
-      Signal.trap('TERM') { shutdown }
-      Signal.trap('INT')  { shutdown! }
-
-      true
-    end
-
     def setup_job_schedule(name, config)
       interval_defined = false
       %w(cron every).each do |interval_type|
-        if config[interval_type].present?
-          RabbitJobs.logger.info "queueing #{config['class']} (#{name})"
-          rufus_scheduler.send(interval_type, config[interval_type], blocking: true) do
-            publish_from_config(config)
-          end
-          interval_defined = true
+        next if config[interval_type].blank?
+        RabbitJobs.logger.info "queueing #{config['class']} (#{name})"
+        rufus_scheduler.send(interval_type, config[interval_type], blocking: true) do
+          publish_from_config(config)
         end
+        interval_defined = true
       end
-      unless interval_defined
-        RabbitJobs.logger.warn "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
-      end
+      return if interval_defined
+
+      RabbitJobs.logger.warn "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
+    end
+
+    def load_default_schedule
+      return unless defined?(Rails)
+      file = Rails.root.join('config/schedule.yml')
+      return unless file.file?
+      @schedule = HashWithIndifferentAccess.new(YAML.load_file(file))
     end
   end
-end
+end