rabbit_jobs 0.11.5 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bbaa1fdb2d8e1c9716955755efa130be1eee820e
-  data.tar.gz: f2b6a65de1baff5a6b4696344ac4fe8d7bc5472c
+  metadata.gz: 41fb778c890aee7f7a0d1a7c7912abbbf58cb1eb
+  data.tar.gz: dbb37f7b51818faa4a1855a16cf2ecdea843d92f
 SHA512:
-  metadata.gz: 0cd1995fc29516e21c31b0cdd5993e0184f06b25eef129d095e39cd83298c89d57206d795023ae21e22c817f947877a9cdedd075ab207e93062b29e99af47924
-  data.tar.gz: dd3ebbf992e689b3afabb00803b7159b89bb9088071b757c38ea3d4174478601ba234c7f2ee440d438768754f990312964cc1dd58242f026b068d82b9c570e63
+  metadata.gz: 42debf0e98af814b76c6b00782645f771e9cc9fb1de85199521ec7b315305745a4023fec0bcf7ff66a14ff21145d9d9656f2e30a2d39d0b67511bccdfa5dcb58
+  data.tar.gz: 4a8a03c5fbfccfcf31f71ae0668cec20f2ae61a6ac12e8d5d43cf372e959d3bbbebe236cdfb7dc4e029b03d8d31288172acf12bbb055c650840b544fb2b7e184

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/build

@@ -1,9 +1,5 @@
 #!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
 require 'fileutils'
 
-abort("rspec tests failed.") unless system("bundle install")
-abort("rspec tests failed.") unless system("COVERAGE=true && bundle exec rspec")
-
-coverage_dir = File.expand_path('../coverage', __FILE__)
-FileUtils.move(coverage_dir, ENV['CC_BUILD_ARTIFACTS']) if ENV['CC_BUILD_ARTIFACTS']
+abort('bundle install failed') unless system('bundle install')
+abort('rspec tests failed.') unless system('bundle exec rspec')

data/examples/client

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# -*- encoding : utf-8 -*-
 
 require 'bundler'
 Bundler.setup
@@ -13,7 +12,7 @@ class MyCurrentJob
 end
 
 RJ.configure { |c|
-  c.queue "mandarin", durable: true, auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
+  c.queue "mandarin", durable: true, auto_delete: false, manual_ack: true, arguments: {'x-ha-policy' => 'all'}
   c.server "amqp://localhost/rj"
 }
 

data/examples/configuration.rb

@@ -6,9 +6,9 @@ require 'json'
 RabbitJobs.configure do |c|
   c.server "amqp://localhost/"
 
-  c.queue 'rabbit_jobs_test1', durable: true, auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
-  c.queue 'rabbit_jobs_test2', durable: true, auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
-  c.queue 'rabbit_jobs_test3', durable: true, auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
+  c.queue 'rabbit_jobs_test1', durable: true, auto_delete: false, manual_ack: true, arguments: {'x-ha-policy' => 'all'}
+  c.queue 'rabbit_jobs_test2', durable: true, auto_delete: false, manual_ack: true, arguments: {'x-ha-policy' => 'all'}
+  c.queue 'rabbit_jobs_test3', durable: true, auto_delete: false, manual_ack: true, arguments: {'x-ha-policy' => 'all'}
 end
 
 puts JSON.pretty_generate(RabbitJobs.config.to_hash)

data/examples/worker

@@ -14,7 +14,7 @@ class MyCurrentJob
 end
 
 RJ.configure { |c|
-  c.queue "mandarin", durable: true, auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
+  c.queue "mandarin", durable: true, auto_delete: false, manual_ack: true, arguments: {'x-ha-policy' => 'all'}
   c.server "amqp://localhost/rj"
 }
 

data/lib/rabbit_jobs.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 require 'logger'
 require 'json'
 require 'bunny'
@@ -11,6 +10,7 @@ require 'active_support/core_ext/module/delegation'
 
 require 'rabbit_jobs/version'
 require 'rabbit_jobs/configuration'
+require 'rabbit_jobs/amqp_transport'
 require 'rabbit_jobs/consumer/job_consumer'
 require 'rabbit_jobs/job'
 require 'rabbit_jobs/publisher'
@@ -19,57 +19,67 @@ require 'rabbit_jobs/worker'
 require 'rabbit_jobs/scheduler'
 require 'rabbit_jobs/tasks'
 
+# Public gem API.
 module RabbitJobs
-  extend self
+  class << self
+    delegate :publish_to, :direct_publish_to, :purge_queue, :queue_status, to: Publisher
 
-  def publish_to(routing_key, klass, *params)
-    Publisher.publish_to(routing_key, klass, *params)
-  end
+    attr_writer :logger
+    def logger
+      unless @logger
+        @logger = Logger.new($stdout)
+        @logger.level = Logger::INFO
+        @logger.formatter = nil
+        @logger.progname = 'rj'
+      end
+      @logger
+    end
 
-  def direct_publish_to(routing_key, payload, ex = {})
-    Publisher.direct_publish_to(routing_key, payload, ex)
-  end
+    def before_process_message(&block)
+      fail unless block_given?
+      @before_process_message_callbacks ||= []
+      @before_process_message_callbacks << block
+    end
 
-  def purge_queue(*routing_keys)
-    Publisher.purge_queue(*routing_keys)
-  end
+    def run_before_process_message_callbacks
+      @before_process_message_callbacks ||= []
+      @before_process_message_callbacks.each do |callback|
+        return false unless callback.call
+      end
+      true
+    rescue
+      false
+    end
 
-  attr_writer :logger
-  def logger
-    unless @logger
-      @logger = Logger.new($stdout)
-      @logger.level = Logger::INFO
-      @logger.formatter = nil
-      @logger.progname = 'rj'
+    # Configuration
+    def configure
+      @configuration ||= Configuration.new
+      yield @configuration if block_given?
     end
-    @logger
-  end
 
-  def after_fork(&block)
-    raise unless block_given?
-    @_after_fork_callbacks ||= []
-    @_after_fork_callbacks << block
-  end
+    def config
+      @configuration ||= load_config
+    end
 
-  def _run_after_fork_callbacks
-    @_after_fork_callbacks ||= []
-    @_after_fork_callbacks.each { |callback|
-      callback.call
-    }
-  end
+    def load_config(config_file = nil)
+      @configuration ||= nil
 
-  def before_process_message(&block)
-    raise unless block_given?
-    @before_process_message_callbacks ||= []
-    @before_process_message_callbacks << block
-  end
+      config_file ||= defined?(Rails) && Rails.respond_to?(:root) && Rails.root.join('config/rabbit_jobs.yml')
+      if config_file
+        if File.exist?(config_file)
+          @configuration ||= Configuration.new
+          @configuration.load_file(config_file)
+        end
+      end
+
+      unless @configuration
+        configure do |c|
+          c.server 'amqp://localhost'
+        end
+      end
 
-  def run_before_process_message_callbacks
-    @before_process_message_callbacks ||= []
-    @before_process_message_callbacks.each { |callback|
-      return false unless callback.call
-    }
-    return true
+      @configuration
+    end
   end
 end
 

data/lib/rabbit_jobs/amqp_transport.rb

@@ -0,0 +1,33 @@
+module RabbitJobs
+  # Connection manager.
+  module AmqpTransport
+    class << self
+      def amqp_connection
+        @amqp_connection ||= Bunny.new(
+          RabbitJobs.config.server,
+          automatically_recover: false,
+          properties: Bunny::Session::DEFAULT_CLIENT_PROPERTIES.merge(product: "rabbit_jobs #{Process.pid}")
+        ).start
+      end
+
+      def publisher_channel
+        @publisher_channel ||= amqp_connection.create_channel(2)
+      end
+
+      def consumer_channel
+        @consumer_channel ||= amqp_connection.create_channel(1)
+      end
+
+      def amqp_cleanup
+        conn = @amqp_connection
+        @amqp_connection = nil
+
+        conn.stop if conn && conn.status != :not_connected
+        @consumer_channel.work_pool.join if @consumer_channel
+        @publisher_channel = nil
+        @consumer_channel = nil
+        true
+      end
+    end
+  end
+end

data/lib/rabbit_jobs/configuration.rb

@@ -1,37 +1,5 @@
-# -*- encoding : utf-8 -*-
 module RabbitJobs
-
-  extend self
-
-  def configure
-    @@configuration ||= Configuration.new
-    yield @@configuration if block_given?
-  end
-
-  def config
-    @@configuration ||= load_config
-  end
-
-  def load_config(config_file = nil)
-    @@configuration ||= nil
-
-    config_file ||= defined?(Rails) && Rails.respond_to?(:root) && Rails.root.join('config/rabbit_jobs.yml')
-    if config_file
-      if File.exists?(config_file)
-        @@configuration ||= Configuration.new
-        @@configuration.load_file(config_file)
-      end
-    end
-
-    unless @@configuration
-      self.configure do |c|
-        c.server "amqp://localhost"
-      end
-    end
-
-    @@configuration
-  end
-
+  # Configuration DSL.
   class Configuration
     DEFAULT_EXCHANGE_PARAMS = {
       auto_delete: false,
@@ -42,7 +10,7 @@ module RabbitJobs
       auto_delete: false,
       exclusive: false,
       durable: true,
-      ack: true
+      manual_ack: true
     }
 
     DEFAULT_MESSAGE_PARAMS = {
@@ -59,7 +27,9 @@ module RabbitJobs
       @data = {
         error_log: true,
         server: 'amqp://localhost',
-        queues: {}
+        queues: {
+          jobs: DEFAULT_QUEUE_PARAMS
+        }
       }
     end
 
@@ -67,14 +37,6 @@ module RabbitJobs
       @data[name]
     end
 
-    def default_queue(value = nil)
-      if value
-        @default_queue = value.to_sym
-      else
-        @default_queue || RJ.config[:queues].keys.first || :jobs
-      end
-    end
-
     def error_log
       @data[:error_log]
     end
@@ -89,8 +51,8 @@ module RabbitJobs
     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)
+      fail ArgumentError, "name is #{name.inspect}" unless name && name.is_a?(String) && name != ''
+      fail ArgumentError, "params is #{params.inspect}" unless params && params.is_a?(Hash)
 
       name = name.downcase.to_sym
 
@@ -105,6 +67,10 @@ module RabbitJobs
       @data[:queues].keys
     end
 
+    def queue?(routing_key)
+      routing_keys.include?(routing_key.to_sym)
+    end
+
     def load_file(filename)
       load_yaml(File.read(filename))
     end
@@ -116,9 +82,9 @@ module RabbitJobs
     def convert_yaml_config(yaml)
       yaml = parse_environment(yaml)
 
-      @data = {queues: {}}
-      %w(server default_queue).each do |m|
-        self.send(m, yaml[m])
+      @data = { queues: {} }
+      %w(server).each do |m|
+        send(m, yaml[m])
       end
       yaml['queues'].each do |name, params|
         queue name, params.symbolize_keys || {}
@@ -128,9 +94,7 @@ module RabbitJobs
     private
 
     def parse_environment(yaml)
-      yaml['rabbit_jobs'] ||
-      (defined?(Rails) && yaml[Rails.env.to_s]) ||
-      yaml
+      yaml['rabbit_jobs'] || (defined?(Rails) && yaml[Rails.env.to_s]) || yaml
     end
   end
 end

data/lib/rabbit_jobs/consumer/job_consumer.rb

@@ -1,32 +1,22 @@
-# -*- encoding : utf-8 -*-
 module RabbitJobs
   module Consumer
+    # Default job consumer.
     class JobConsumer
-      def process_message(delivery_info, properties, payload)
-        job, *error_args = RJ::Job.parse(payload)
+      def process_message(_delivery_info, _properties, payload)
+        job, params = RJ::Job.parse(payload)
 
         if job.is_a?(Symbol)
-          report_error(job, *error_args)
+          report_error(job, *params)
         else
           if job.expired?
-            RJ.logger.warn "Job expired: #{job.to_ruby_string}"
+            RJ.logger.warn "Job expired: #{job.to_ruby_string(*params)}"
           else
-            job.run_perform
+            job.send(:run_perform, *params)
           end
         end
         true
       end
 
-      def log_airbrake(msg_or_exception, payload)
-        if defined?(Airbrake)
-          if msg_or_exception.is_a?(String)
-            Airbrake.notify(RuntimeError.new(msg_or_exception))
-          else
-            Airbrake.notify(msg_or_exception)
-          end
-        end
-      end
-
       def report_error(error_type, *args)
         case error_type
         when :not_found
@@ -40,4 +30,4 @@ module RabbitJobs
       end
     end
   end
-end
+end

data/lib/rabbit_jobs/job.rb

@@ -1,162 +1,137 @@
-# -*- encoding : utf-8 -*-
 require 'benchmark'
 
 module RabbitJobs
+  # Module to include in client jobs.
   module Job
-    extend self
+    attr_accessor :created_at
 
-    def self.included(base)
-      base.extend (ClassMethods)
+    def expired?
+      exp_in = self.class.expires_in.to_i
+      return false if exp_in == 0 || created_at.nil?
 
-      def initialize(*perform_params)
-        self.params = perform_params
-        self.opts = {}
-      end
-
-      attr_accessor :params, :opts
-
-      def run_perform
-        begin
-          ret = nil
-          execution_time = Benchmark.measure { ret = perform(*params) }
-          RabbitJobs.logger.info short_message: "Completed: #{self.to_ruby_string}", _execution_time: execution_time.to_s.strip
-        rescue ScriptError, StandardError
-          log_job_error($!)
-          run_on_error_hooks($!)
-        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
+      Time.now.to_i > created_at + exp_in
+    end
 
-            begin
-              case proc.arity
-              when 0
-                proc.call()
-              when 1
-                proc.call(error)
-              else
-                proc.call(error, *params)
-              end
-            rescue
-              RJ.logger.error($!)
-            end
-          end
-        end
-      end
+    def to_ruby_string(*params)
+      rs = self.class.name + params_string(*params)
+      rs << ", created_at: #{created_at}" if created_at
+      rs
+    end
 
-      def payload
-        {'class' => self.class.to_s, 'opts' => (self.opts || {}), 'params' => params}.to_json
-      end
+    private
 
-      def expires_in
-        self.class.rj_expires_in
+    def params_string(*params)
+      if params.count > 0
+        "(#{params.map(&:to_s).join(', ')})"
+      else
+        ''
       end
+    end
 
-      def expires?
-        self.expires_in && self.expires_in > 0
-      end
+    def log_job_error(error, *params)
+      RabbitJobs.logger.error(
+        short_message: (error.message.presence || 'rj_worker job error'),
+        _job: to_ruby_string,
+        _exception: error.class,
+        full_message: error.backtrace.join("\r\n"))
 
-      def expires_at_expired?
-        expires_at = opts['expires_at'].to_i
-        return false if expires_at == 0
-        Time.now.to_i > expires_at
-      end
+      Airbrake.notify(error, session: { args: to_ruby_string(*params) }) if defined?(Airbrake)
+    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 run_perform(*params)
+      ret = nil
+      execution_time = Benchmark.measure { ret = perform(*params) }
+      RabbitJobs.logger.info(
+        short_message: "Completed: #{to_ruby_string(*params)}",
+        _execution_time: execution_time.to_s.strip)
+    rescue ScriptError, StandardError
+      log_job_error($!, *params)
+      run_on_error_hooks($!, *params)
+    end
 
-        Time.now.to_i > created_at + exp_in
-      end
+    def run_on_error_hooks(error, *params)
+      return unless @@rj_on_error_hooks.try(:present?)
 
-      def expired?
-        expires_at_expired? || expires_in_expired?
-      end
+      @@rj_on_error_hooks.each do |proc_or_symbol|
+        proc = if proc_or_symbol.is_a?(Symbol)
+                 method(proc_or_symbol)
+               else
+                 proc_or_symbol
+               end
 
-      def to_ruby_string
-        rs = self.class.name
-        rs << params_string
-        if opts.count > 0
-          rs << ", opts: "
-          rs << opts.inspect
+        begin
+          case proc.arity
+          when 0
+            proc.call
+          when 1
+            proc.call(error)
+          else
+            proc.call(error, *params)
+          end
+        rescue
+          RJ.logger.error($!)
         end
       end
+    end
 
-      def params_string
-        if params.count > 0
-          "(#{params.map(&:to_s).join(", ")})"
-        else
-          ""
-        end
+    class << self
+      def parse(payload)
+        encoded = JSON.parse(payload)
+        job_klass = encoded['class'].to_s.constantize
+        job = job_klass.new
+        job.created_at = encoded['created_at']
+        [job, encoded['params']]
+      rescue NameError
+        [:not_found, encoded['class']]
+      rescue JSON::ParserError
+        [:parsing_error, payload]
+      rescue
+        [:error, $!, payload]
       end
 
-      def log_job_error(error)
-        RabbitJobs.logger.error(short_message: (error.message.presence || "rj_worker job error"),
-          _job: self.to_ruby_string, _exception: error.class, full_message: error.backtrace.join("\r\n"))
-
-        Airbrake.notify(error, session: {args: self.to_ruby_string}) if defined?(Airbrake)
+      def serialize(klass_name, *params)
+        {
+          'class' => klass_name.to_s,
+          'created_at' => Time.now.to_i,
+          'params' => params
+        }.to_json
       end
-    end
 
-    module ClassMethods
-      attr_accessor :rj_expires_in, :rj_on_error_hooks
+      def included(base)
+        base.extend(ClassMethods)
+        base.queue(:jobs)
+      end
 
       # DSL method for jobs
-      def expires_in(seconds)
-       @rj_expires_in = seconds.to_i
-      end
+      module ClassMethods
+        def expires_in(seconds = nil)
+          @expires_in = seconds.to_i if seconds
+          @expires_in
+        end
 
-      def on_error(*hooks)
-        hooks.each do |proc_or_symbol|
-          raise ArgumentError.new("Pass proc or symbol to on_error hook") unless proc_or_symbol && ( proc_or_symbol.is_a?(Proc) || proc_or_symbol.is_a?(Symbol) )
+        def on_error(*hooks)
           @rj_on_error_hooks ||= []
-          @rj_on_error_hooks << proc_or_symbol
+          hooks.each do |proc_or_symbol|
+            unless proc_or_symbol.is_a?(Proc) || proc_or_symbol.is_a?(Symbol)
+              fail ArgumentError.new, 'Pass proc or symbol to on_error hook'
+            end
+            @rj_on_error_hooks << proc_or_symbol
+          end
         end
-      end
 
-      def queue(routing_key)
-        raise ArgumentError.new("routing_key is nil") unless routing_key.present?
-        @rj_queue = routing_key.to_sym
-      end
-
-      def perform_async(*args)
-        RJ::Publisher.publish_to(@rj_queue || RJ.config.default_queue, self, *args)
-      end
+        def queue(routing_key)
+          fail ArgumentError, 'routing_key is blank' if routing_key.blank?
+          @rj_queue = routing_key.to_sym
+        end
 
-      def perform(*params)
-        new.perform(*params)
-      end
-    end
+        def perform_async(*args)
+          RJ::Publisher.publish_to(@rj_queue, self, *args)
+        end
 
-    def self.parse(payload)
-      begin
-        encoded = JSON.parse(payload)
-        job_klass = encoded['class'].to_s.constantize
-        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]
+        def perform(*params)
+          new.perform(*params)
+        end
       end
     end
-
-    def self.serialize(klass_name, *params)
-      {
-        'class' => klass_name.to_s,
-        'opts' => {'created_at' => Time.now.to_i},
-        'params' => params
-      }.to_json
-    end
   end
 end