rabbit_jobs 0.7.8 → 0.7.9

data/lib/rabbit_jobs/amqp_helper.rb

@@ -1,6 +1,4 @@
 # -*- encoding : utf-8 -*-
-require 'bunny'
-require 'uri'
 
 module RabbitJobs
   class AmqpHelper
@@ -8,7 +6,7 @@ module RabbitJobs
     class << self
 
       def prepare_connection
-        conn = Bunny.new(RJ.config.server, :heartbeat_interval => 5)
+        conn = Bunny.new(RabbitJobs.config.server, :heartbeat_interval => 5)
         conn.start unless conn.connected? || conn.connecting?
         conn
       end

data/lib/rabbit_jobs/configuration.rb

@@ -1,7 +1,4 @@
 # -*- encoding : utf-8 -*-
-require 'yaml'
-require 'uri'
-
 module RabbitJobs
 
   extend self
@@ -28,7 +25,7 @@ module RabbitJobs
 
     unless @@configuration
       self.configure do |c|
-        c.prefix 'rabbit_jobs'
+        c.server "amqp://localhost"
       end
     end
 
@@ -63,8 +60,7 @@ module RabbitJobs
     def initialize
       @data = {
         error_log: true,
-        server: 'amqp://localhost/',
-        prefix: 'rabbit_jobs',
+        server: 'amqp://localhost',
         queues: {}
       }
     end
@@ -102,15 +98,6 @@ module RabbitJobs
       @data[:server]
     end
 
-    def prefix(value = nil)
-      if value
-        raise ArgumentError unless value.is_a?(String) && value != ""
-        @data[:prefix] = value.downcase
-      else
-        @data[:prefix]
-      end
-    end
-
     def queue(name, params = {})
       raise ArgumentError.new("name is #{name.inspect}") unless name && name.is_a?(String) && name != ""
       raise ArgumentError.new("params is #{params.inspect}") unless params && params.is_a?(Hash)
@@ -128,11 +115,6 @@ module RabbitJobs
       @data[:queues].keys
     end
 
-    def queue_name(routing_key)
-      routing_key = routing_key.to_sym
-      @data[:queues][routing_key][:ignore_prefix] ? routing_key : [@data[:prefix], routing_key].compact.join('#')
-    end
-
     def load_file(filename)
       load_yaml(File.read(filename))
     end
@@ -142,19 +124,23 @@ module RabbitJobs
     end
 
     def convert_yaml_config(yaml)
-      if yaml['rabbit_jobs']
-        convert_yaml_config(yaml['rabbit_jobs'])
-      elsif defined?(Rails) && yaml[Rails.env.to_s]
-        convert_yaml_config(yaml[Rails.env.to_s])
-      else
-        @data = {prefix: nil, queues: {}}
-        %w(server prefix mail_errors_to mail_errors_from).each do |m|
-          self.send(m, yaml[m])
-        end
-        yaml['queues'].each do |name, params|
-          queue name, symbolize_keys!(params) || {}
-        end
+      yaml = parse_environment(yaml)
+
+      @data = {queues: {}}
+      %w(server mail_errors_to mail_errors_from).each do |m|
+        self.send(m, yaml[m])
+      end
+      yaml['queues'].each do |name, params|
+        queue name, symbolize_keys!(params) || {}
       end
     end
+
+    private
+
+    def parse_environment(yaml)
+      yaml['rabbit_jobs'] ||
+      (defined?(Rails) && yaml[Rails.env.to_s]) ||
+      yaml
+    end
   end
 end

data/lib/rabbit_jobs/consumer/job_consumer.rb

@@ -3,9 +3,10 @@ module RabbitJobs
   module Consumer
     class JobConsumer
       def process_message(delivery_info, properties, payload)
-        job = RJ::Job.parse(payload)
+        job, *error_args = RJ::Job.parse(payload)
 
         if job.is_a?(Symbol)
+          report_error(job, *error_args)
           # case @job
           # when :not_found
           # when :parsing_error
@@ -23,5 +24,25 @@ module RabbitJobs
         true
       end
     end
+
+    def log_error(msg)
+      RJ.logger.error msg
+    end
+
+    def report_error(error_type, *args)
+      case error_type
+      when :not_found
+        log_error "Cannot find job class '#{args.first}'"
+      when :parsing_error
+        log_error "Cannot initialize job. Json parsing error."
+        log_error "Data received: #{args.first.inspect}"
+      when :error
+        ex, payload = args
+        log_error "Cannot initialize job."
+        log_error ex.message
+        log_error _cleanup_backtrace(ex.backtrace).join("\n")
+        log_error "Data received: #{payload.inspect}"
+      end
+    end
   end
 end

data/lib/rabbit_jobs/error_mailer.rb

@@ -1,35 +1,47 @@
 # -*- encoding : utf-8 -*-
 module RabbitJobs
   class ErrorMailer
-    def self.enabled?
-      !!(
-        defined?(ActionMailer) && \
-        RabbitJobs.config.mail_errors_from && !RabbitJobs.config.mail_errors_from.empty? && \
-        RabbitJobs.config.mail_errors_to && !RabbitJobs.config.mail_errors_to.empty?
-      )
-    end
+    class << self
+      def enabled?
+        defined?(ActionMailer) && config_present?
+      end
+
+      def send_letter(subject, body)
+        letter         = ActionMailer::Base.mail
+        letter.from    = RabbitJobs.config.mail_errors_from
+        letter.to      = RabbitJobs.config.mail_errors_to
+        letter.subject = subject
+        letter.body    = body
+
+        letter.deliver
+      end
 
-    def self.report_error(job, error = $!)
-      return unless enabled?
+      def report_error(job, error = $!)
+        return unless enabled?
 
-      params ||= []
+        begin
+          subject, text = build_error_message(job, error)
+          send_letter(subject, text)
+        rescue
+          RabbitJobs.logger.error [$!.message, $!.backtrace].flatten.join("\n")
+        end
+      end
 
-      params_str = job.params == [] ? '' : job.params.map { |p| p.inspect }.join(', ')
-      subject = "RJ:Worker: #{error.class} on #{job.class}"
-      text    = "\n#{job.class}.perform(#{params_str})\n"
-      text   += "\n#{error.inspect}\n"
-      text   += "\nBacktrace:\n#{error.backtrace.join("\n")}" if error.backtrace
+      private
 
-      letter         = ActionMailer::Base.mail
-      letter.from    = RabbitJobs.config.mail_errors_from
-      letter.to      = RabbitJobs.config.mail_errors_to
-      letter.subject = subject
-      letter.body    = text
+      def build_error_message(job, error)
+        params = job.params || []
 
-      begin
-        letter.deliver
-      rescue
-        RJ.logger.error [$!.message, $!.backtrace].flatten.join("\n")
+        params_str = params.map { |p| p.inspect }.join(', ')
+        subject = "RJ:Worker: #{error.class} on #{job.class}"
+        text    = "\n#{job.class}.perform(#{params_str})\n"
+        text   += "\n#{error.inspect}\n"
+        text   += "\nBacktrace:\n#{error.backtrace.join("\n")}" if error.backtrace
+      end
+
+      def config_present?
+        config = RabbitJobs.config
+        config.mail_errors_from.present? && config.mail_errors_to.present?
       end
     end
   end

data/lib/rabbit_jobs/job.rb

@@ -1,130 +1,138 @@
 # -*- encoding : utf-8 -*-
-require 'json'
-require 'digest/md5'
+module RabbitJobs
+  module Job
+    include RabbitJobs::Helpers
+    extend self
 
-module RabbitJobs::Job
-  extend RabbitJobs::Helpers
-  extend self
+    def self.included(base)
+      base.extend (ClassMethods)
 
-  def self.included(base)
-    base.extend (ClassMethods)
+      def initialize(*perform_params)
+        self.params = perform_params
+        self.opts = {}
+      end
 
-    def initialize(*perform_params)
-      self.params = perform_params
-      self.opts = {}
-    end
+      attr_accessor :params, :opts
+
+      def run_perform
+        begin
+          start_time = Time.now
+          RabbitJobs.logger.info "Started to perform #{self.to_ruby_string}"
+          self.class.perform(*params)
+          execution_time = Time.now - start_time
+          RabbitJobs.logger.info "     Job completed #{self.to_ruby_string} in #{execution_time} seconds."
+        rescue
+          log_job_error($!)
+          run_on_error_hooks($!)
+        end
+      end
 
-    attr_accessor :params, :opts
+      def run_on_error_hooks(error)
+        if self.class.rj_on_error_hooks
+          self.class.rj_on_error_hooks.each do |proc_or_symbol|
+            proc = proc_or_symbol
+            if proc_or_symbol.is_a?(Symbol)
+              proc = self.method(proc_or_symbol)
+            end
+
+            case proc.arity
+            when 0
+              proc.call()
+            when 1
+              proc.call(error)
+            else
+              proc.call(error, *params)
+            end
+          end
+        end
+      end
 
-    def run_perform
-      begin
-        start_time = Time.now
-        RJ.logger.info "Started to perform #{self.to_ruby_string}"
-        self.class.perform(*params)
-        execution_time = Time.now - start_time
-        RJ.logger.info "     Job completed #{self.to_ruby_string} in #{execution_time} seconds."
-      rescue
-        RJ.logger.warn $!.message
-        RJ.logger.warn(self.to_ruby_string)
-        RJ.logger.warn _cleanup_backtrace($!.backtrace).join("\n")
-        run_on_error_hooks($!)
-        RabbitJobs::ErrorMailer.report_error(self, $!)
+      def payload
+        {'class' => self.class.to_s, 'opts' => (self.opts || {}), 'params' => params}.to_json
       end
-    end
 
-    def run_on_error_hooks(error)
-      if self.class.rj_on_error_hooks
-        self.class.rj_on_error_hooks.each do |proc_or_symbol|
-          proc = proc_or_symbol
-          if proc_or_symbol.is_a?(Symbol)
-            proc = self.method(proc_or_symbol)
-          end
+      def expires_in
+        self.class.rj_expires_in
+      end
 
-          case proc.arity
-          when 0
-            proc.call()
-          when 1
-            proc.call(error)
-          else
-            proc.call(error, *params)
-          end
-        end
+      def expires?
+        self.expires_in && self.expires_in > 0
       end
-    end
 
-    def payload
-      {'class' => self.class.to_s, 'opts' => (self.opts || {}), 'params' => params}.to_json
-    end
+      def expires_at_expired?
+        expires_at = opts['expires_at'].to_i
+        return false if expires_at == 0
+        Time.now.to_i > expires_at
+      end
 
-    def expires_in
-      self.class.rj_expires_in
-    end
+      def expires_in_expired?
+        exp_in = self.expires_in.to_i
+        created_at = opts['created_at'].to_i
+        return false if exp_in == 0 || created_at == 0
 
-    def expires?
-      self.expires_in && self.expires_in > 0
-    end
+        Time.now.to_i > created_at + exp_in
+      end
 
-    def expired?
-      if self.opts['expires_at']
-        Time.now.to_i > opts['expires_at'].to_i
-      elsif expires? && opts['created_at']
-        Time.now.to_i > (opts['created_at'].to_i + expires_in.to_i)
-      else
-        false
+      def expired?
+        expires_at_expired? || expires_in_expired?
       end
-    end
 
-    def to_ruby_string
-      rs = self.class.name
-      if params.count > 0
-        rs << "("
-          rs << params.map(&:to_s).join(", ")
-        rs << ")"
+      def to_ruby_string
+        rs = self.class.name
+        rs << params_string
+        if opts.count > 0
+          rs << ", opts: "
+          rs << opts.inspect
+        end
       end
-      if opts.count > 0
-        rs << ", opts: "
-        rs << opts.inspect
+
+      def params_string
+        if params.count > 0
+          "(#{params.map(&:to_s).join(", ")})"
+        else
+          ""
+        end
+      end
+
+      def log_job_error(error)
+        RabbitJobs.logger.warn error.message
+        RabbitJobs.logger.warn(self.to_ruby_string)
+        RabbitJobs.logger.warn _cleanup_backtrace(error.backtrace).join("\n")
+        RabbitJobs::ErrorMailer.report_error(self, error) rescue nil
       end
     end
-  end
 
-  module ClassMethods
-    attr_accessor :rj_expires_in, :rj_on_error_hooks
+    module ClassMethods
+      attr_accessor :rj_expires_in, :rj_on_error_hooks
 
-    # DSL method for jobs
-    def expires_in(seconds)
-     @rj_expires_in = seconds.to_i
-    end
+      # DSL method for jobs
+      def expires_in(seconds)
+       @rj_expires_in = seconds.to_i
+      end
 
-    def on_error(*hooks)
-      hooks.each do |proc_or_symbol|
-        raise ArgumentError unless proc_or_symbol && ( proc_or_symbol.is_a?(Proc) || proc_or_symbol.is_a?(Symbol) )
-        @rj_on_error_hooks ||= []
-        @rj_on_error_hooks << proc_or_symbol
+      def on_error(*hooks)
+        hooks.each do |proc_or_symbol|
+          raise ArgumentError unless proc_or_symbol && ( proc_or_symbol.is_a?(Proc) || proc_or_symbol.is_a?(Symbol) )
+          @rj_on_error_hooks ||= []
+          @rj_on_error_hooks << proc_or_symbol
+        end
       end
     end
-  end
 
-  def self.parse(payload)
-    begin
-      encoded = JSON.parse(payload)
-      job_klass = constantize(encoded['class'])
-      job = job_klass.new(*encoded['params'])
-      job.opts = encoded['opts']
-      job
-    rescue NameError
-      RJ.logger.error "Cannot find job class '#{encoded['class']}'"
-      :not_found
-    rescue JSON::ParserError
-      RJ.logger.error "Cannot initialize job. Json parsing error."
-      RJ.logger.error "Data received: #{payload.inspect}"
-      :parsing_error
-    rescue
-      RJ.logger.warn "Cannot initialize job."
-      RJ.logger.warn $!.message
-      RJ.logger.warn _cleanup_backtrace($!.backtrace).join("\n")
-      RJ.logger.warn "Data received: #{payload.inspect}"
-      :error
+    def self.parse(payload)
+      begin
+        encoded = JSON.parse(payload)
+        job_klass = constantize(encoded['class'])
+        job = job_klass.new(*encoded['params'])
+        job.opts = encoded['opts']
+        job
+      rescue NameError
+        [:not_found, encoded['class']]
+      rescue JSON::ParserError
+        [:parsing_error, payload]
+      rescue
+        [:error, $!, payload]
+      end
     end
   end
-end
+end

data/lib/rabbit_jobs/main_loop.rb

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+module RabbitJobs
+  module MainLoop
+    def shutdown
+      @shutdown = true
+    end
+
+    def shutdown!
+      shutdown
+    end
+
+    def main_loop(time)
+      while true
+        sleep 1
+        if time > 0
+          time -= 1
+          if time == 0
+            shutdown
+          end
+        end
+
+        if @shutdown
+          RabbitJobs.logger.info "Stopping."
+          yield if block_given?
+          return true
+        end
+      end
+    end
+
+    def log_daemon_error(error)
+      if RabbitJobs.logger
+        begin
+          RabbitJobs.logger.error [error.message, error.backtrace].flatten.join("\n")
+        ensure
+          abort(error.message)
+        end
+      end
+    end
+  end
+end

data/lib/rabbit_jobs/publisher.rb

@@ -1,11 +1,5 @@
 # -*- encoding : utf-8 -*-
 
-require 'json'
-require 'bunny'
-require 'uri'
-require 'active_support'
-require 'active_support/core_ext/module'
-
 module RabbitJobs
   module Publisher
     extend self
@@ -17,8 +11,9 @@ module RabbitJobs
     end
 
     def publish_to(routing_key, klass, *params)
-      raise ArgumentError.new("klass=#{klass.inspect}") unless klass && (klass.is_a?(Class) || klass.is_a?(String))
-      raise ArgumentError.new("routing_key=#{routing_key}") unless routing_key && (routing_key.is_a?(Symbol) || routing_key.is_a?(String)) && !!RJ.config[:queues][routing_key.to_sym]
+      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]
 
       payload = {
         'class' => klass.to_s,
@@ -26,35 +21,43 @@ module RabbitJobs
         'params' => params
         }.to_json
 
-      direct_publish_to(RJ.config.queue_name(routing_key.to_sym), payload)
+      direct_publish_to(routing_key, payload)
     end
 
     def direct_publish_to(routing_key, payload, ex = {})
       check_connection
       begin
-        exchange = get_exchange(ex)
-        exchange.publish(payload, Configuration::DEFAULT_MESSAGE_PARAMS.merge({key: routing_key.to_sym}))
-        # channel.wait_for_confirms
+        exchange_name = ex.delete(:name).to_s
+        exchange_opts = Configuration::DEFAULT_MESSAGE_PARAMS.merge(ex || {})
+        connection.default_channel.basic_publish(payload, exchange_name, routing_key, exchange_opts)
       rescue
-        RJ.logger.warn $!.message
-        RJ.logger.warn $!.backtrace.join("\n")
+        RabbitJobs.logger.warn $!.message
+        RabbitJobs.logger.warn $!.backtrace.join("\n")
         raise $!
       end
 
       true
     end
 
+    def queue_status(routing_key)
+      raise ArgumentError unless routing_key.present?
+
+      routing_key = routing_key.to_sym
+      queue_declare_ok = connection.default_channel.queue_declare(routing_key, RabbitJobs.config[:queues][routing_key].merge(passive: true))
+      {
+        message_count: queue_declare_ok.message_count,
+        consumer_count: queue_declare_ok.consumer_count
+      }
+    end
+
     def purge_queue(*routing_keys)
-      raise ArgumentError unless routing_keys && routing_keys.count > 0
+      raise ArgumentError unless routing_keys.present?
 
       messages_count = 0
-      count = routing_keys.count
 
       routing_keys.map(&:to_sym).each do |routing_key|
-        queue_name = RJ.config.queue_name(routing_key)
-        queue = connection.queue(queue_name, RJ.config[:queues][routing_key])
-        messages_count += queue.status[:message_count]
-        queue.purge
+        messages_count += queue_status(routing_key)[:message_count].to_i
+        connection.default_channel.queue_purge(routing_key)
       end
 
       messages_count
@@ -68,29 +71,13 @@ module RabbitJobs
 
     def connection
       unless settings[:connection]
-        settings[:connection] = Bunny.new(RJ.config.server, :heartbeat_interval => 5)
+        settings[:connection] = Bunny.new(RabbitJobs.config.server, :heartbeat_interval => 5)
         settings[:connection].start
         # settings[:channel].confirm_select
       end
       settings[:connection]
     end
 
-    def exchanges
-      settings[:exchanges] ||= {}
-    end
-
-    def get_exchange(ex = {})
-      ex = {name: ex} if ex.is_a?(String)
-      raise ArgumentError.new("Need to pass exchange name") if ex.size > 0 && ex[:name].to_s.empty?
-
-      if ex.size > 0
-        exchange_opts = Configuration::DEFAULT_EXCHANGE_PARAMS.merge(ex[:params] || {}).merge({type: (ex[:type] || :direct)})
-        exchanges[ex[:name]] ||= connection.default_channel.exchange(ex[:name].to_s, exchange_opts)
-      else
-        exchanges[ex[:name]] ||= connection.default_channel.default_exchange
-      end
-    end
-
     def check_connection
       raise unless connection.connected?
     end

data/lib/rabbit_jobs/scheduler.rb

@@ -1,19 +1,20 @@
 # -*- encoding : utf-8 -*-
-
-require 'rufus/scheduler'
-require 'thwait'
-require 'yaml'
-
 module RabbitJobs
   class Scheduler
+    include MainLoop
 
-    attr_accessor :schedule, :process_name
+    attr_reader :schedule, :process_name
+    attr_writer :process_name
+
+    def schedule=(value)
+      @schedule = HashWithIndifferentAccess.new(value)
+    end
 
     def load_default_schedule
       if defined?(Rails)
         file = Rails.root.join('config/schedule.yml')
         if file.file?
-          @schedule = YAML.load_file(file)
+          @schedule = HashWithIndifferentAccess.new(YAML.load_file(file))
         end
       end
     end
@@ -31,21 +32,7 @@ module RabbitJobs
         # job should be scheduled regardless of what ENV['RAILS_ENV'] is set
         # to.
         if config['rails_env'].nil? || rails_env_matches?(config)
-          interval_defined = false
-          interval_types = %w{cron every}
-          interval_types.each do |interval_type|
-            if !config[interval_type].nil? && config[interval_type].length > 0
-              RJ.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
-              break
-            end
-          end
-          unless interval_defined
-            RJ.logger.warn "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
-          end
+          setup_job_schedule(name, config)
         end
       end
     end
@@ -57,16 +44,15 @@ module RabbitJobs
 
     # Publish a job based on a config hash
     def publish_from_config(config)
-      args = config['args'] || config[:args] || []
-      klass_name = config['class'] || config[:class]
-      params = args.is_a?(Hash) ? [args] : Array(args)
-      queue = config['queue'] || config[:queue] || RJ.config.routing_keys.first
+      args = config[:args] || []
+      klass_name = config[:class]
+      params = [args].flatten
 
-      RJ.logger.info "publishing #{config} at #{Time.now}"
-      RJ.publish_to(queue, klass_name, *params)
+      RabbitJobs.logger.info "publishing #{config} at #{Time.now}"
+      RabbitJobs.publish_to(config[:queue], klass_name, *params)
     rescue
-      RJ.logger.warn "Failed to publish #{klass_name}:\n #{$!}\n params = #{params.inspect}"
-      RJ.logger.warn $!.inspect
+      RabbitJobs.logger.warn "Failed to publish #{klass_name}:\n #{$!}\n params = #{params.inspect}"
+      RabbitJobs.logger.warn $!.inspect
     end
 
     def rufus_scheduler
@@ -88,46 +74,18 @@ module RabbitJobs
 
         $0 = self.process_name || "rj_scheduler"
 
-        RJ.logger.info "Started."
+        RabbitJobs.logger.info "Started."
 
-        processed_count = 0
         load_schedule!
 
-        while true
-          sleep 1
-          if time > 0
-            time -= 1
-            if time == 0
-              shutdown
-            end
-          end
-
-          if @shutdown
-            RJ.logger.info "Processed jobs: #{processed_count}."
-            RJ.logger.info "Stopped."
-
-            return true
-          end
-        end
-      rescue => e
-        error = $!
-        if RJ.logger
-          begin
-            RJ.logger.error [error.message, error.backtrace].flatten.join("\n")
-          ensure
-            abort(error.message)
-          end
-        end
+        return main_loop(time)
+      rescue
+        log_daemon_error($!)
       end
 
       true
     end
 
-    def shutdown
-      RJ.logger.info "Stopping..."
-      @shutdown = true
-    end
-
     def startup
       # Fix buffering so we can `rake rj:work > resque.log` and
       # get output from the child in there.
@@ -141,8 +99,20 @@ module RabbitJobs
       true
     end
 
-    def shutdown!
-      shutdown
+    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
+        end
+      end
+      unless interval_defined
+        RabbitJobs.logger.warn "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
+      end
     end
   end
 end

data/lib/rabbit_jobs/tasks.rb

@@ -1,6 +1,4 @@
 require 'rabbit_jobs'
-require 'logger'
-require 'rake'
 
 def rails_env
   $my_rails_env ||= defined?(Rails) ? Rails.env : (ENV['RAILS_ENV'] || 'development')

data/lib/rabbit_jobs/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 
 module RabbitJobs
-  VERSION = "0.7.8"
+  VERSION = "0.7.9"
 end

data/lib/rabbit_jobs/worker.rb

@@ -2,12 +2,14 @@
 
 module RabbitJobs
   class Worker
+    include MainLoop
+
     attr_accessor :process_name
     attr_reader :consumer
 
-    def consumer=(consumer)
-      raise ArgumentError.new("consumer=#{consumer.inspect}") unless consumer.respond_to?(:process_message)
-      @consumer = consumer
+    def consumer=(value)
+      raise ArgumentError.new("value=#{value.inspect}") unless value.respond_to?(:process_message)
+      @consumer = value
     end
 
     def amqp_connection
@@ -20,12 +22,8 @@ module RabbitJobs
       Thread.current[:rj_worker_connection] = nil
     end
 
-    def queue_name(routing_key)
-      RJ.config.queue_name(routing_key)
-    end
-
     def queue_params(routing_key)
-      RJ.config[:queues][routing_key]
+      RJ.config[:queues][routing_key.to_sym]
     end
 
     # Workers should be initialized with an array of string queue
@@ -58,79 +56,28 @@ module RabbitJobs
 
       $0 = self.process_name || "rj_worker (#{queues.join(', ')})"
 
-      processed_count = 0
+      @processed_count = 0
 
       begin
-        # amqp_channel.prefetch(1)
-
         amqp_channel = amqp_connection.create_channel
+        amqp_channel.prefetch(1)
 
-        queue_objects = []
         queues.each do |routing_key|
-          RJ.logger.info "Subscribing to #{queue_name(routing_key)}"
-
-          routing_key = routing_key.to_sym
-          queue = amqp_channel.queue(queue_name(routing_key), queue_params(routing_key))
-          queue_objects << queue
-          explicit_ack = !!queue_params(routing_key)[:ack]
-
-          queue.subscribe(ack: explicit_ack) do |delivery_info, properties, payload|
-            if RJ.run_before_process_message_callbacks
-              begin
-                @consumer.process_message(delivery_info, properties, payload)
-                processed_count += 1
-              rescue
-                RJ.logger.warn "process_message failed. payload: #{payload.inspect}"
-                RJ.logger.warn $!.inspect
-                $!.backtrace.each {|l| RJ.logger.warn l}
-              end
-              amqp_channel.ack(delivery_info.delivery_tag, false) if explicit_ack
-            else
-              RJ.logger.warn "before_process_message hook failed, requeuing payload: #{payload.inspect}"
-              amqp_channel.nack(delivery_info.delivery_tag, true) if explicit_ack
-            end
-
-            if @shutdown
-              queue_objects.each {|q| q.unsubscribe}
-            end
-          end
+          consume_queue(amqp_channel, routing_key)
         end
 
         RJ.logger.info "Started."
 
-        while true
-          sleep 1
-          if time > 0
-            time -= 1
-            if time == 0
-              shutdown
-            end
-          end
-
-          if @shutdown
-            RJ.logger.info "Processed jobs: #{processed_count}."
-            RJ.logger.info "Stopped."
-            return true
-          end
-        end
+        return main_loop(time) {
+          RJ.logger.info "Processed jobs: #{@processed_count}."
+        }
       rescue
-        error = $!
-        if RJ.logger
-          begin
-            RJ.logger.error [error.message, error.backtrace].flatten.join("\n")
-          ensure
-            abort(error.message)
-          end
-        end
+        log_daemon_error($!)
       end
 
       true
     end
 
-    def shutdown
-      @shutdown = true
-    end
-
     def startup
       count = RJ._run_after_fork_callbacks
 
@@ -144,8 +91,38 @@ module RabbitJobs
       true
     end
 
-    def shutdown!
-      shutdown
+    private
+
+    def consume_message(delivery_info, properties, payload)
+      if RJ.run_before_process_message_callbacks
+        begin
+          @consumer.process_message(delivery_info, properties, payload)
+          @processed_count += 1
+        rescue
+          RJ.logger.warn "process_message failed. payload: #{payload.inspect}"
+          RJ.logger.warn $!.inspect
+          $!.backtrace.each {|l| RJ.logger.warn l}
+        end
+        true
+      else
+        RJ.logger.warn "before_process_message hook failed, requeuing payload: #{payload.inspect}"
+        false
+      end
+    end
+
+    def consume_queue(amqp_channel, routing_key)
+      RJ.logger.info "Subscribing to #{routing_key}"
+      routing_key = routing_key.to_sym
+      queue = amqp_channel.queue(routing_key, queue_params(routing_key))
+      explicit_ack = !!queue_params(routing_key)[:ack]
+
+      queue.subscribe(ack: explicit_ack) do |delivery_info, properties, payload|
+        if consume_message(delivery_info, properties, payload)
+          amqp_channel.ack(delivery_info.delivery_tag, false) if explicit_ack
+        else
+          amqp_channel.nack(delivery_info.delivery_tag, true) if explicit_ack
+        end
+      end
     end
   end
 end

data/lib/rabbit_jobs.rb

@@ -1,6 +1,15 @@
 # -*- encoding : utf-8 -*-
 require 'logger'
 require 'rake'
+require 'json'
+require 'digest/md5'
+require 'bunny'
+require 'uri'
+require 'rufus/scheduler'
+require 'thwait'
+require 'yaml'
+require 'active_support'
+require 'active_support/core_ext'
 
 require 'rabbit_jobs/version'
 
@@ -12,6 +21,7 @@ require 'rabbit_jobs/error_mailer'
 require 'rabbit_jobs/consumer/job_consumer'
 require 'rabbit_jobs/job'
 require 'rabbit_jobs/publisher'
+require 'rabbit_jobs/main_loop'
 require 'rabbit_jobs/worker'
 require 'rabbit_jobs/scheduler'
 require 'rabbit_jobs/tasks'
@@ -20,15 +30,15 @@ module RabbitJobs
   extend self
 
   def publish_to(routing_key, klass, *params)
-    RJ::Publisher.publish_to(routing_key, klass, *params)
+    Publisher.publish_to(routing_key, klass, *params)
   end
 
   def direct_publish_to(routing_key, payload, ex = {})
-    RJ::Publisher.direct_publish_to(routing_key, payload, ex)
+    Publisher.direct_publish_to(routing_key, payload, ex)
   end
 
   def purge_queue(*routing_keys)
-    RJ::Publisher.purge_queue(*routing_keys)
+    Publisher.purge_queue(*routing_keys)
   end
 
   attr_writer :logger

data/spec/fixtures/config.yml

@@ -1,6 +1,5 @@
 rabbit_jobs:
   server: amqp://example.com/vhost
-  prefix: 'rabbit_jobs'
   queues:
     durable_queue:
       durable: true

data/spec/fixtures/jobs.rb

@@ -34,7 +34,7 @@ class JobWithPublish
   def self.perform(param = 0)
     if param < 5
       puts "publishing job #{param}"
-      RJ.publish JobWithPublish, param + 1
+      RJ.publish_to :rspec_durable_queue, JobWithPublish, param + 1
     else
       puts "processing job #{param}"
     end
@@ -64,4 +64,9 @@ class JobWithArgsArray
   def perform(first_param, *other_args)
     puts "#{self.class.name}.perform called with first_param: #{first_param.inspect} and other_args: #{other_args.inspect}"
   end
+end
+
+class TestConsumer
+  def process_message *args
+  end
 end

data/spec/integration/publisher_spec.rb

@@ -43,7 +43,7 @@ describe RabbitJobs::Publisher do
   end
 
   it 'should publish 1000 messages in one second' do
-    count = 100
+    count = 1000
     published = 0
     time = Benchmark.measure {
       count.times {
@@ -51,7 +51,7 @@ describe RabbitJobs::Publisher do
       }
       # sleep 0.1
       removed = RJ.purge_queue(:rspec_queue, :rspec_queue2, :rspec_queue3)
-      removed.should == 100
+      removed.should == 1000
     }
     puts time
   end

data/spec/integration/worker_spec.rb

@@ -4,39 +4,43 @@ require 'spec_helper'
 describe RabbitJobs::Worker do
   it 'should listen for messages' do
     RabbitJobs.configure do |c|
-      c.prefix 'test_durable'
+      c.server 'amqp://localhost/rj'
       c.queue 'rspec_durable_queue', auto_delete: false, durable: true, ack: true
     end
 
     RJ::Publisher.purge_queue('rspec_durable_queue')
     count = 5
     5.times {
-      RabbitJobs.publish(PrintTimeJob, Time.now)
+      RabbitJobs.publish_to(:rspec_durable_queue, PrintTimeJob, Time.now)
     }
 
     Timecop.freeze(Time.now - 4600) {
-      5.times { RabbitJobs.publish(JobWithExpire) }
+      5.times { RabbitJobs.publish_to(:rspec_durable_queue, JobWithExpire) }
     }
 
-    RabbitJobs.publish(JobWithErrorHook)
+    RabbitJobs.publish_to(:rspec_durable_queue, JobWithErrorHook)
 
     worker = RabbitJobs::Worker.new
+    RJ.logger.level = Logger::FATAL
 
+    mock(PrintTimeJob).perform(anything).times(5)
+    mock(JobWithErrorHook).perform
+    dont_allow(JobWithExpire).perform
     worker.work(1) # work for 1 second
     RJ::Publisher.purge_queue('rspec_durable_queue')
   end
 
   it 'should allow to publish jobs from worker' do
     RabbitJobs.configure do |c|
-      c.prefix 'test_durable'
+      c.server 'amqp://localhost/rj'
       c.queue 'rspec_durable_queue', auto_delete: false, durable: true, ack: true
     end
 
     RJ::Publisher.purge_queue('rspec_durable_queue')
-    RabbitJobs.publish(JobWithPublish)
+    RabbitJobs.publish_to(:rspec_durable_queue, JobWithPublish, 1)
 
     worker = RabbitJobs::Worker.new
-
-    worker.work(1) # work for 1 second
+    # mock(RJ).publish_to(:rspec_durable_queue, JobWithPublish, 5)
+    worker.work(3) # work for 1 second
   end
 end

data/spec/spec_helper.rb

@@ -20,4 +20,12 @@ RSpec.configure do |config|
     # clear config options
     RabbitJobs.class_variable_set '@@configuration', nil
   end
+
+  if ENV['CC_BUILD_ARTIFACTS']
+    # "-c -f p -f h -o #{ENV['CC_BUILD_ARTIFACTS']}/rspec_report.html"
+    config.out = File.open "#{ENV['CC_BUILD_ARTIFACTS']}/rspec_report.html", 'w'
+    # config.color_enabled = true
+    # config.formatter = :progress
+    config.formatter = :html
+  end
 end

data/spec/unit/configuration_spec.rb

@@ -8,8 +8,6 @@ describe RabbitJobs::Configuration do
 
       c.server "amqp://somehost.lan"
 
-      c.prefix 'my_prefix'
-
       c.queue 'durable_queue', durable: true,  auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
       c.queue 'fast_queue',    durable: false, auto_delete: true,  ack: false
     end
@@ -17,7 +15,6 @@ describe RabbitJobs::Configuration do
     RabbitJobs.config.to_hash.should == {
       error_log: false,
       server: "amqp://somehost.lan",
-      prefix: "my_prefix",
       queues: {
         durable_queue: {
           auto_delete: false,
@@ -40,7 +37,6 @@ describe RabbitJobs::Configuration do
     RabbitJobs.config.load_file(File.expand_path('../../fixtures/config.yml', __FILE__))
 
     RabbitJobs.config.to_hash.should == {
-      prefix: "rabbit_jobs",
       server: "amqp://example.com/vhost",
       queues: {
         durable_queue: {
@@ -60,19 +56,17 @@ describe RabbitJobs::Configuration do
     }
   end
 
-  it 'use default values for #server and #prefix' do
+  it 'use default value for #server' do
     RabbitJobs.config.to_hash.should == {
       error_log: true,
-      server: "amqp://localhost/",
-      prefix: "rabbit_jobs",
+      server: "amqp://localhost",
       queues: {}
     }
   end
 
   it 'returns settings on some methods' do
     RabbitJobs.config.error_log == true
-    RabbitJobs.config.server.should == 'amqp://localhost/'
+    RabbitJobs.config.server.should == 'amqp://localhost'
     RabbitJobs.config.routing_keys.should == []
-    RabbitJobs.config.prefix.should == 'rabbit_jobs'
   end
 end

data/spec/unit/worker_spec.rb

@@ -2,30 +2,25 @@
 require 'spec_helper'
 
 describe RabbitJobs::Worker do
-  describe 'methods' do
-    before :each do
-      @worker = RabbitJobs::Worker.new
-    end
 
-    it '#initialize with default options' do
-      @worker.queues.should == [:default]
+  before(:each) do
+    RJ.configure do |c|
+      c.server 'amqp://localhost'
+      c.queue "default"
     end
+  end
 
-    it '#startup should set @shutdown to false' do
-      @worker.instance_variable_get('@shutdown').should_not == true
-
-      mock(Signal).trap('TERM')
-      mock(Signal).trap('INT')
-
-      @worker.startup
+  let(:worker) { RJ::Worker.new(:default) }
 
-      @worker.instance_variable_get('@shutdown').should_not == true
-    end
+  describe '#consumer' do
+    it 'validates consumer type' do
+      old_consumer = worker.consumer
+      lambda { worker.consumer = 123 }.should raise_error
+      worker.consumer.should == old_consumer
 
-    it '#shutdown should set @shutdown to true' do
-      @worker.instance_variable_get('@shutdown').should_not == true
-      @worker.shutdown
-      @worker.instance_variable_get('@shutdown').should == true
+      new_consumer = TestConsumer.new
+      lambda { worker.consumer = new_consumer }.should_not raise_error
+      worker.consumer.should == new_consumer
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rabbit_jobs
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.7.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-22 00:00:00.000000000 Z
+date: 2013-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
-  requirement: &9230940 !ruby/object:Gem::Requirement
+  requirement: &17412060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -21,10 +21,10 @@ dependencies:
         version: 0.9.0.pre8
   type: :runtime
   prerelease: false
-  version_requirements: *9230940
+  version_requirements: *17412060
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &9229700 !ruby/object:Gem::Requirement
+  requirement: &17409580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *9229700
+  version_requirements: *17409580
 - !ruby/object:Gem::Dependency
   name: rufus-scheduler
-  requirement: &9349960 !ruby/object:Gem::Requirement
+  requirement: &17800900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '2.0'
   type: :runtime
   prerelease: false
-  version_requirements: *9349960
+  version_requirements: *17800900
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &9697740 !ruby/object:Gem::Requirement
+  requirement: &17799580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *9697740
+  version_requirements: *17799580
 description: Background jobs on RabbitMQ
 email:
 - lazureykis@gmail.com
@@ -81,6 +81,7 @@ files:
 - lib/rabbit_jobs/error_mailer.rb
 - lib/rabbit_jobs/helpers.rb
 - lib/rabbit_jobs/job.rb
+- lib/rabbit_jobs/main_loop.rb
 - lib/rabbit_jobs/publisher.rb
 - lib/rabbit_jobs/scheduler.rb
 - lib/rabbit_jobs/tasks.rb
@@ -114,7 +115,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1729098954943910884
+      hash: -1527066833663791632
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -123,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1729098954943910884
+      hash: -1527066833663791632
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11