rabbit_jobs 0.2.0.pre4 → 0.3

data/Gemfile

@@ -12,4 +12,5 @@ group :development do
   gem 'autotest-fsevent'
   gem 'autotest-growl'
   gem 'simplecov', require: false
+  gem 'pry'
 end

data/bin/rj_scheduler

@@ -0,0 +1,23 @@
+#!/bin/env ruby
+require 'pathname'
+require 'bundler/setup'
+require 'rake'
+
+rails_root = Pathname.new(Dir.getwd)
+ENV['RAILS_ROOT'] = rails_root.to_s
+ENV['RAILS_ENV'] ||= 'development'
+
+require File.expand_path('../../lib/rabbit_jobs/tasks', __FILE__)
+
+case ARGV.first
+when 'start'
+  require 'bundler/setup'
+  require rails_root.join('config/application')
+  Rake::Task['rj:scheduler:start'].invoke
+when 'stop'
+  Rake::Task['rj:scheduler:stop'].invoke
+when 'status'
+  Rake::Task['rj:scheduler:status'].invoke
+else
+  raise "usage: rj_scheduler <start>|<stop>|<status>"
+end

data/bin/rj_worker

@@ -0,0 +1,24 @@
+#!/bin/env ruby
+require 'pathname'
+require 'bundler/setup'
+require 'rake'
+
+ENV['RAILS_ENV'] ||= 'development'
+
+rails_root = Pathname.new(Dir.getwd)
+
+require 'bundler/setup'
+require rails_root.join('config/application')
+Rails.application.require_environment!
+Rails.application.load_tasks
+
+case ARGV.first
+  when 'start'
+  Rake::Task['rj:worker:start'].invoke
+  when 'stop'
+  Rake::Task['rj:worker:stop'].invoke
+  when 'status'
+  Rake::Task['rj:worker:status'].invoke
+else
+  raise "usage: rj_worker <start>|<stop>|<status>"
+end

data/examples/client

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# -*- encoding : utf-8 -*-
+
+require 'bundler'
+Bundler.setup
+require File.expand_path('../../lib/rabbit_jobs', __FILE__)
+
+class MyCurrentJob
+  include RJ::Job
+  def self.perform(count)
+  end
+end
+
+RJ.configure { |c|
+  c.queue "failover_test"
+  c.server "amqp://dev.lan/"
+  c.server "amqp://localhost/"
+
+}
+
+RJ.logger = Logger.new($stdout)
+
+RJ.run {
+  RJ.publish(MyCurrentJob) {
+    puts 'published first message'
+    RJ.stop
+  }
+
+  # EM.add_timer(5) {
+  #   RJ.publish(MyCurrentJob) {
+  #     puts 'published second message'
+  #     RJ.stop
+  #   }
+  # }
+}
+
+
+# 1000.times {
+#   RJ.run do
+#     count = 10000
+#     published = 0
+#     count.times {
+#       RJ.publish_to(:default, MyCurrentJob) {
+#         published += 1
+#         RJ.stop if published >= count
+#       }
+#     }
+#   end
+#   puts 'returned from em'
+# }

data/examples/configuration.rb

@@ -4,7 +4,7 @@ require 'rabbit_jobs'
 require 'json'
 
 RabbitJobs.configure do |c|
-  c.url        "amqp://localhost/"
+  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'}

data/examples/worker

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# -*- encoding : utf-8 -*-
+
+require 'bundler'
+Bundler.setup
+require File.expand_path('../../lib/rabbit_jobs', __FILE__)
+
+class MyCurrentJob
+  include RJ::Job
+  def self.perform(count = 0)
+    # puts count
+    # RJ.publish_to(:default, MyCurrentJob, count - 1) if count > 0
+  end
+end
+
+RJ.configure { |c|
+  c.queue "failover_test"
+  c.server "amqp://localhost/"
+  c.server "amqp://dev.lan/"
+}
+
+# AMQ::Client.logging = false
+AMQP.logging = false
+
+RJ.logger = Logger.new($stdout)
+
+worker = RJ::Worker.new
+worker.work

data/lib/rabbit_jobs.rb

@@ -18,17 +18,101 @@ require 'logger'
 module RabbitJobs
   extend self
 
-  def publish(klass, *params)
-    RabbitJobs::Publisher.publish(klass, *params)
+  def start
+    raise unless block_given?
+    raise if EM.reactor_running?
+
+    EM.run {
+      AmqpHelper.prepare_connection
+      yield
+    }
+  end
+
+  alias_method :run, :start
+
+  def stop
+    if AMQP.connection
+      AMQP.connection.disconnect {
+        AMQP.connection = nil
+        AMQP.channel = nil
+        EM.stop {
+          yield if block_given?
+        }
+      }
+    else
+      EM.stop {
+        yield if block_given?
+      }
+    end
+  end
+
+  def running?
+    EM.reactor_running?
+  end
+
+  def publish(klass, *params, &block)
+    if RJ.running?
+      RJ::Publisher.publish(klass, *params, &block)
+    else
+      RJ.run {
+        RJ::Publisher.publish(klass, *params) {
+          RJ.stop {
+            yield if block_given?
+          }
+        }
+      }
+    end
+  end
+
+  def publish_to(routing_key, klass, *params, &block)
+    if RJ.running?
+      RJ::Publisher.publish_to(routing_key, klass, *params, &block)
+    else
+      RJ.run {
+        RJ::Publisher.publish_to(routing_key, klass, *params) {
+          RJ.stop {
+            yield if block_given?
+          }
+        }
+      }
+    end
   end
 
-  def publish_to(routing_key, klass, *params)
-    RabbitJobs::Publisher.publish_to(routing_key, klass, *params)
+  def purge_queue(*routing_keys, &block)
+    if RJ.running?
+      RJ::Publisher.purge_queue(*routing_keys, &block)
+    else
+      RJ.run {
+        RJ::Publisher.purge_queue(*routing_keys) { |count|
+          RJ.stop {
+            yield if block_given?
+            return count
+          }
+        }
+      }
+    end
   end
 
   attr_writer :logger
   def logger
-    @logger ||= Logger.new $stdout
+    unless @logger
+      @logger = Logger.new($stdout)
+      # @logger.level = Logger::WARN
+    end
+    @logger
+  end
+
+  def after_fork(&block)
+    raise unless block_given?
+    @_after_fork_callbacks ||= []
+    @_after_fork_callbacks << block
+  end
+
+  def _run_after_fork_callbacks
+    @_after_fork_callbacks ||= []
+    @_after_fork_callbacks.each { |callback|
+      callback.call
+    }
   end
 end
 

data/lib/rabbit_jobs/amqp_helper.rb

@@ -5,56 +5,108 @@ require 'uri'
 module RabbitJobs
   class AmqpHelper
 
+    # Timeout to recover connection.
+    RECOVERY_TIMEOUT = 3
+    HOSTS_DEAD = []
+    HOSTS_FAILED = {}
+
     class << self
-      # Calls given block with initialized amqp connection.
-      def with_amqp
-        raise ArgumentError unless block_given?
 
-        if EM.reactor_running?
-          yield false
-        else
-          AMQP.start(RJ.config.url) {
-            init_auto_recovery
-            yield true
-          }
+      def prepare_connection
+        if !AMQP.connection || AMQP.connection.closed?
+          RJ.logger.info("rj[##{Process.pid}] Connecting to #{RJ.config.servers.first.to_s}...")
+          AMQP.connection = AMQP.connect(RJ.config.servers.first, auto_recovery: true)
+          init_auto_recovery
         end
       end
 
       def prepare_channel
-        unless AMQP.channel
-          create_channel
-        else
-          create_channel unless AMQP.channel.open?
+        AMQP.channel ||= AMQP::Channel.new(AMQP.connection, auto_recovery: true)
+      end
+
+      def init_auto_recovery
+        unless $auto_recovery_initiated
+          $auto_recovery_initiated = true
+
+          AMQP.connection.on_recovery do |conn, opts|
+            HOSTS_DEAD.clear
+            HOSTS_FAILED.clear
+            url = url_from_opts opts
+            RJ.logger.warn "rj[##{Process.pid}] Connection to #{url} recovered."
+          end
+
+          AMQP.connection.on_open do |conn, opts|
+            RJ.logger.info "rj[##{Process.pid}] Connected."
+          end
+
+          # AMQP.connection.before_recovery do |conn, opts|
+          #   RJ.logger.info "rj[##{Process.pid}] before_recovery"
+          # end
+
+          # AMQP.connection.on_possible_authentication_failure do |conn, opts|
+          #   puts opts.inspect
+          #   # restore_from_connection_failure(opts)
+          # end
+
+          AMQP.connection.on_tcp_connection_loss do |conn, opts|
+            sleep 2
+            restore_from_connection_failure(opts)
+          end
+
+          # AMQP.connection.on_connection_interruption do |conn|
+          #   # restore_from_connection_failure(opts)
+          # end
+
+          AMQP.connection.on_tcp_connection_failure do |opts|
+            sleep 2
+            restore_from_connection_failure(opts)
+          end
         end
       end
 
       private
 
-      def init_auto_recovery
-        AMQP.connection.on_recovery do |conn, opts|
-          url = url_from_opts opts
-          RJ.logger.warn "[network failure] Connection to #{url} established."
+      def restore_from_connection_failure(opts)
+        url = opts.empty? ? RJ.config.servers.first : url_from_opts(opts)
+        HOSTS_FAILED[url] ||= Time.now
+
+        if HOSTS_FAILED[url] + RECOVERY_TIMEOUT < Time.now
+          # reconnect to another host
+          HOSTS_DEAD.push(url) unless HOSTS_DEAD.include?(url)
+          new_url = (RJ.config.servers.dup - HOSTS_DEAD.dup).first
+          if new_url
+            reconnect_to(new_url)
+          else
+            # all hosts is dead
+          end
+        else
+          # reconnect to the same host
+          reconnect_to(url)
         end
+      end
 
-        AMQP.connection.on_tcp_connection_loss do |conn, opts|
-          url = url_from_opts opts
-          RJ.logger.warn "[network failure] Trying to reconnect to #{url}..."
-          conn.reconnect(false, 2)
+      def reconnect_to(url)
+        if AMQP.connection
+          RJ.logger.warn "rj[##{Process.pid}] Trying to reconnect to #{url}..."
+          AMQP.connection.reconnect_to(url, 2)
+        else
+          RJ.logger.warn "rj[##{Process.pid}] Trying to connect to #{url}..."
+          AMQP.connection = AMQP.connect(url, auto_recovery: true)
+          init_auto_recovery
         end
       end
 
       def url_from_opts(opts = {})
+        return "" unless opts
+        return "" if opts.empty?
         s = ""
-        s << opts[:scheme]
+        s << (opts[:scheme] || "amqp")
         s << "://"
-        s << "#{opts[:user]}@" if opts[:user] && opts[:user] != 'guest'
+        s << "#{opts[:user]}@" if opts[:user] && !opts[:user].empty? && opts[:user] != 'guest'
         s << opts[:host]
         s << ":#{opts[:port]}" unless (opts[:scheme] == 'amqp' && opts[:port] == 5672) || (opts[:scheme] == 'amqps' && opts[:port] == 5673)
-        s << opts[:vhost]
-      end
-
-      def create_channel
-        AMQP.channel = AMQP::Channel.new(AMQP.connection, auto_recovery: true)
+        s << opts[:vhost] if opts[:vhost] && !opts[:vhost].empty? && opts[:vhost] != "/"
+        s
       end
     end
   end

data/lib/rabbit_jobs/configuration.rb

@@ -28,7 +28,6 @@ module RabbitJobs
 
     unless @@configuration
       self.configure do |c|
-        c.url 'amqp://localhost'
         c.prefix 'rabbit_jobs'
       end
     end
@@ -41,6 +40,7 @@ module RabbitJobs
 
     DEFAULT_QUEUE_PARAMS = {
       auto_delete: false,
+      exclusive: false,
       durable: true,
       ack: true
     }
@@ -58,7 +58,7 @@ module RabbitJobs
     def initialize
       @data = {
         error_log: true,
-        url: 'amqp://localhost',
+        servers: [],
         prefix: 'rabbit_jobs',
         queues: {}
       }
@@ -92,14 +92,20 @@ module RabbitJobs
       @data[:error_log] = false
     end
 
-    def url(value = nil)
-      if value
-        raise ArgumentError unless value.is_a?(String) && value != ""
-        @data[:url] = value.to_s
-        @data.delete :connection_options
-      else
-        @data[:url] || 'amqp://localhost'
+    def servers(*value)
+      unless value.empty?
+        @data[:servers] = value.map(&:to_s).map(&:strip).keep_if{|url|!url.empty?}.map {|url|
+          normalize_url(url)
+        }
       end
+      @data[:servers]
+    end
+
+    def server(value = nil)
+      raise unless value && !value.to_s.empty?
+      value = normalize_url(value.to_s.strip)
+      @data[:servers] ||= []
+      @data[:servers] << value unless @data[:servers].include?(value)
     end
 
     def prefix(value = nil)
@@ -155,14 +161,25 @@ module RabbitJobs
       elsif defined?(Rails) && yaml[Rails.env.to_s]
         convert_yaml_config(yaml[Rails.env.to_s])
       else
-        @data = {url: nil, prefix: nil, queues: {}}
-        %w(url prefix mail_errors_to mail_errors_from).each do |m|
+        @data = {prefix: nil, queues: {}}
+        %w(prefix mail_errors_to mail_errors_from).each do |m|
           self.send(m, yaml[m])
         end
+        yaml['servers'].split(",").each do |value|
+          server normalize_url(value)
+        end
         yaml['queues'].each do |name, params|
           queue name, symbolize_keys!(params) || {}
         end
       end
     end
+
+    private
+
+    def normalize_url(url_string)
+      uri = URI.parse(url_string)
+      uri.path = "" if uri.path.to_s == "/"
+      uri.to_s
+    end
   end
 end