rabbit_jobs 0.2.0.pre4 → 0.3

data/lib/rabbit_jobs/job.rb

@@ -18,11 +18,11 @@ module RabbitJobs::Job
 
     def run_perform
       begin
-        RJ.logger.info "Running perform on #{self.inspect}"
+        RJ.logger.info "rj_worker[##{Process.pid}] performing #{self.to_ruby_string}"
         self.class.perform(*params)
       rescue
-        RJ.logger.warn(self.inspect)
         RJ.logger.warn $!.message
+        RJ.logger.warn(self.to_ruby_string)
         RJ.logger.warn RJ::Util.cleanup_backtrace($!.backtrace).join("\n")
         run_on_error_hooks($!)
         RabbitJobs::ErrorMailer.report_error(self, $!)
@@ -70,6 +70,19 @@ module RabbitJobs::Job
         false
       end
     end
+
+    def to_ruby_string
+      rs = self.class.name
+      if params.count > 0
+        rs << "("
+          rs << params.map(&:to_s).join(", ")
+        rs << ")"
+      end
+      if opts.count > 0
+        rs << ", opts: "
+        rs << opts.inspect
+      end
+    end
   end
 
   module ClassMethods
@@ -99,12 +112,16 @@ module RabbitJobs::Job
     rescue NameError
       RJ.logger.error "Cannot find job class '#{encoded['class']}'"
       :not_found
+    rescue JSON::ParserError
+      RJ.logger.error "rj[##{Process.pid}] Cannot initialize job. Json parsing error."
+      RJ.logger.error "rj[##{Process.pid}] Data received: #{payload.inspect}"
+      :parsing_error
     rescue
-      RJ.logger.error "JOB INIT ERROR at #{Time.now.to_s}:"
+      RJ.logger.warn "rj[##{Process.pid}] Cannot initialize job."
       RJ.logger.warn $!.message
       RJ.logger.warn RJ::Util.cleanup_backtrace($!.backtrace).join("\n")
-      RJ.logger.error "message: #{payload.inspect}"
-      nil
+      RJ.logger.warn "Data received: #{payload.inspect}"
+      :error
     end
   end
 end

data/lib/rabbit_jobs/publisher.rb

@@ -9,8 +9,8 @@ module RabbitJobs
   module Publisher
     extend self
 
-    def publish(klass, *params)
-      publish_to(RJ.config.default_queue, klass, *params)
+    def publish(klass, *params, &block)
+      publish_to(RJ.config.default_queue, klass, *params, &block)
     end
 
     def publish_to(routing_key, klass, *params)
@@ -18,55 +18,48 @@ module RabbitJobs
       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_s]
 
       begin
-        AmqpHelper.with_amqp do |stop_em|
-          AmqpHelper.prepare_channel
+        payload = {
+          'class' => klass.to_s,
+          'opts' => {'created_at' => Time.now.to_i},
+          'params' => params
+          }.to_json
 
-          payload = {
-            'class' => klass.to_s,
-            'opts' => {'created_at' => Time.now.to_i},
-            'params' => params
-            }.to_json
+        AmqpHelper.prepare_channel
 
-          AMQP::Exchange.default.publish(payload, Configuration::DEFAULT_MESSAGE_PARAMS.merge({key: RJ.config.queue_name(routing_key.to_s)})) do
-            if stop_em
-              AMQP.connection.disconnect { EM.stop }
-            end
-          end
+        AMQP.channel.default_exchange.publish(payload, Configuration::DEFAULT_MESSAGE_PARAMS.merge({key: RJ.config.queue_name(routing_key.to_s)})) do
+          yield if block_given?
         end
       rescue
-        raise $!
-        RJ.logger.warn $!.inspect
+        RJ.logger.warn $!.message
         RJ.logger.warn $!.backtrace.join("\n")
+        raise $!
       end
 
       true
     end
 
-    def purge_queue(*routing_keys)
+    def purge_queue(*routing_keys, &block)
       raise ArgumentError unless routing_keys && routing_keys.count > 0
 
       messages_count = 0
-
       count = routing_keys.count
 
-      AmqpHelper.with_amqp do |stop_em|
-        routing_keys.each do |routing_key|
-          queue = AMQP.channel.queue(RJ.config.queue_name(routing_key), RJ.config[:queues][routing_key.to_s])
-          queue.status do |messages, consumers|
-            # messages_count += messages
-            queue.purge do |ret|
-              raise "Cannot purge queue #{routing_key.to_s}." unless ret.is_a?(AMQ::Protocol::Queue::PurgeOk)
-              messages_count += ret.message_count
-              count -= 1
-              if count == 0 && stop_em
-                AMQP.connection.disconnect { EM.stop }
-              end
+      AmqpHelper.prepare_channel
+
+      routing_keys.each do |routing_key|
+        queue = AMQP.channel.queue(RJ.config.queue_name(routing_key), RJ.config[:queues][routing_key.to_s])
+        queue.status do |messages, consumers|
+          # messages_count += messages
+          queue.purge do |ret|
+            raise "Cannot purge queue #{routing_key.to_s}." unless ret.is_a?(AMQ::Protocol::Queue::PurgeOk)
+            messages_count += ret.message_count
+            count -= 1
+            if count == 0
+              yield messages_count if block_given?
             end
           end
         end
       end
-
-      return messages_count
     end
   end
 end

data/lib/rabbit_jobs/scheduler.rb

@@ -70,6 +70,7 @@ module RabbitJobs
     end
 
     def rufus_scheduler
+      raise "Cannot start without eventmachine running." unless EM.reactor_running?
       @rufus_scheduler ||= Rufus::Scheduler.start_new
     end
 
@@ -83,44 +84,48 @@ module RabbitJobs
 
     # Subscribes to channel and working on jobs
     def work(time = 0)
-      return false unless startup
+      begin
+        return false unless startup
 
-      $0 = self.process_name || "rj_scheduler"
+        $0 = self.process_name || "rj_scheduler"
 
-      processed_count = 0
-      AmqpHelper.with_amqp do |stop_em|
-        AmqpHelper.prepare_channel
+        processed_count = 0
+        RJ.run do
+          AmqpHelper.prepare_channel
 
-        load_schedule!
+          load_schedule!
 
-        check_shutdown = Proc.new {
-          if @shutdown
-            AMQP.connection.disconnect {
-              File.delete(self.pidfile) if self.pidfile
-              EM.stop { exit! }
-            }
-          end
-        }
+          check_shutdown = Proc.new {
+            if @shutdown
+              RJ.stop {
+                File.delete(self.pidfile) if self.pidfile
+              }
+              RJ.logger.info "rj_scheduler[##{Process.pid}] stopped."
+            end
+          }
 
-        if time > 0
-          # for debugging
-          EM.add_timer(time) do
-            self.shutdown
+          if time > 0
+            EM.add_timer(time) do
+              self.shutdown
+            end
           end
-        end
 
-        RJ.logger.info "Scheduler started."
+          EM.add_periodic_timer(1) do
+            check_shutdown.call
+          end
 
-        EM.add_periodic_timer(1) do
-          check_shutdown.call
+          RJ.logger.info "rj_scheduler[##{Process.pid}] started."
         end
+      rescue => e
+        RJ.logger.error e.message
+        RJ.logger.error e.backtrace.join("\r\n")
       end
 
       true
     end
 
     def shutdown
-      RJ.logger.warn "Stopping scheduler..."
+      RJ.logger.info "rj_scheduler[##{Process.pid}] stopping..."
       @shutdown = true
     end
 
@@ -138,14 +143,14 @@ module RabbitJobs
         end
       end
 
-      if self.pidfile
-        File.open(self.pidfile, 'w') { |f| f << Process.pid }
-      end
-
       # Fix buffering so we can `rake rj:work > resque.log` and
       # get output from the child in there.
       $stdout.sync = true
 
+      if self.pidfile
+        File.open(self.pidfile, 'w') { |f| f << Process.pid }
+      end
+
       @shutdown = false
 
       Signal.trap('TERM') { shutdown }

data/lib/rabbit_jobs/tasks.rb

@@ -1,46 +1,228 @@
-# require 'resque/tasks'
+# require 'rabbit_jobs/tasks'
 # will give you the resque tasks
 
 require 'rabbit_jobs'
 require 'logger'
+require 'rake'
 
-namespace :rj do
-  def initialize_rj_daemon(daemon)
-    daemon.pidfile = ENV['PIDFILE']
-    daemon.background = %w(yes true).include? ENV['BACKGROUND']
-    RJ.logger = ::Logger.new(ENV['LOGFILE'] || $stdout)
-    RJ.logger.level = ENV['VERBOSE'] ? Logger::INFO : Logger::WARN
+def rails_env
+  $my_rails_env ||= defined?(Rails) ? Rails.env : (ENV['RAILS_ENV'] || 'development')
+end
+
+def app_root
+  $my_rails_root ||= Pathname.new(ENV['RAILS_ROOT'] || Rails.root)
+end
 
-    daemon
+def make_dirs
+  ["log", "tmp", "tmp/pids"].each do |subdir|
+    dir = app_root.join(subdir)
+    Dir.mkdir(dir) unless File.directory?(dir)
   end
+end
 
-  desc "Start a Rabbit Jobs worker"
-  task :worker => :environment do
-    require 'rabbit_jobs'
+namespace :rj do
+  task :environment do
+    # Rails.application.eager_load!
+    Rails.application.require_environment!
+  end
 
-    queues = (ENV['QUEUES'] || ENV['QUEUE']).to_s.split(',')
-    worker = initialize_rj_daemon(RJ::Worker.new(*queues))
+  # MULTIPROCESS
+  namespace :worker do
+    desc "Start a Rabbit Jobs workers from config/rj_workers.yml"
+    task :start => [:environment, :load_config] do
+      make_dirs
+      @rj_config.each do |worker_name, worker_props|
+        worker_num = 1
+        worker_props['instances'].to_i.times do
+          unless @do_only.count > 0 && !@do_only.include?("#{worker_name}-#{worker_num}")
+            queues = (worker_props['queue'] || worker_props['queues'] || "").split(' ')
 
-    exit(0) if worker.work
-  end
+            worker = RJ::Worker.new(*queues)
+            worker.background = true
+            worker.process_name = "rj_worker #{worker_name}##{worker_num} #{rails_env} [#{queues.join(',')}]"
+            worker.pidfile = app_root.join("tmp/pids/rj_worker_#{rails_env}_#{worker_name}_#{worker_num}.pid")
+            RJ.logger = ::Logger.new(app_root.join("log/rj_worker_#{rails_env}_#{worker_name}_#{worker_num}.log"), 'daily')
+            # RJ.logger.level = ENV['VERBOSE'] ? Logger::INFO : Logger::WARN
+            puts "Starting #{worker_name}##{worker_num}"
+
+            # завершаем копию процесса, если воркер уже отработал
+            exit! if worker.work
+          end
+          worker_num += 1
+        end
+      end
+    end
+
+    task :stop => :load_config do
+      # получаем идентификаторы процессов
+      pids = {}
+      errors = []
+
+      @rj_config.each do |worker_name, worker_props|
+        worker_num = 1
+        worker_props['instances'].to_i.times do
+          unless (@do_only.count > 0) && !@do_only.include?("#{worker_name}-#{worker_num}")
+            pidfile = app_root.join("tmp/pids/rj_worker_#{rails_env}_#{worker_name}_#{worker_num}.pid")
+
+            unless File.exists?(pidfile)
+              msg = "Pidfile not found: #{pidfile}"
+              errors << msg
+              $stderr.puts msg
+            else
+              pid = open(pidfile).read.to_i
+              pids[pid] = pidfile
+              queues = (worker_props['queue'] || worker_props['queues'] || "").split(' ')
+              puts "Stopping rj_worker #{worker_name}##{worker_num} #{rails_env} [#{queues.join(',')}]"
+            end
+          end
+          worker_num += 1
+        end
+      end
+
+      # пытаемся их убить
+      killed_pids = []
+      pids.each do |pid, pidfile|
+        begin
+          puts "try killing ##{pid}"
+          Process.kill("TERM", pid)
+        rescue => e
+          errors << "Not found process: #{pid} from #{pidfile}"
+          $stderr.puts errors.last
+          $stderr.puts "Removing pidfile ..."
+          File.delete(pidfile) if File.exist?(pidfile)
+        end
+      end
+
+      while killed_pids.count != pids.keys.count
+        pids.each_key do |pid|
+          begin
+            Process.kill(0, pid)
+            stopped = false
+            break
+          rescue
+            killed_pids.push(pid) unless killed_pids.include?(pid)
+          end
+        end
+        print '.'
+        sleep 1
+      end
+
+      exit(1) if not errors.empty?
+
+      puts "\nrj_worker stopped."
+      exit(0)
+    end
+
+    task :status => :load_config do
+
+      errors ||= 0
 
-  desc "Start a Rabbit Jobs scheduler"
-  task :scheduler => :environment do
-    scheduler = initialize_rj_daemon(RabbitJobs::Scheduler.new)
+      @rj_config.each do |worker_name, worker_props|
+        worker_num = 1
+        worker_props['instances'].to_i.times do
+          pidfile = app_root.join("tmp/pids/rj_worker_#{rails_env}_#{worker_name}_#{worker_num}.pid")
 
-    scheduler.work
+          unless File.exists?(pidfile)
+            puts "Pidfile not found: #{pidfile}"
+            errors += 1
+          else
+            pid = open(pidfile).read.to_i
+            begin
+              raise "must return 1" unless Process.kill(0, pid) == 1
+            rescue
+              puts "Pidfile found but process not respond: #{pidfile}\r\nRemoving pidfile."
+              File.delete(pidfile) if File.exist?(pidfile)
+              errors += 1
+            end
+          end
+          worker_num += 1
+        end
+      end
+
+      puts "ok" if errors == 0
+      exit errors
+    end
+
+    task :load_config do
+      @rj_config = YAML.load(open app_root.join("config/rj_workers.yml"))
+      @rj_config = @rj_config[rails_env]
+
+      @do_only = ENV["WORKERS"] ? ENV["WORKERS"].strip.split : []
+      @do_only.each do |worker|
+        worker_name, worker_num = worker.split('-')
+        unless @rj_config.keys.include?(worker_name) && @rj_config[worker_name]['instances'].to_i >= worker_num.to_i
+          raise "Worker #{worker} not found."
+        end
+      end
+    end
   end
 
-  # Preload app files if this is Rails
-  task :environment do
-    if defined?(Rails) && Rails.respond_to?(:application)
-      # Rails 3
-      # Rails.application.eager_load!
-      Rails.application.require_environment!
-    elsif defined?(Rails::Initializer)
-      # Rails 2.3
-      $rails_rake_task = false
-      Rails::Initializer.run :load_application_classes
+  namespace :scheduler do
+    task :start do
+      make_dirs
+
+      scheduler = RabbitJobs::Scheduler.new
+
+      scheduler.background = true
+      scheduler.pidfile = app_root.join('tmp/pids/rj_scheduler.pid')
+      RJ.logger = ::Logger.new(app_root.join('log/rj_scheduler.log'), 'daily')
+      # RJ.logger.level = ENV['VERBOSE'] ? Logger::INFO : Logger::WARN
+
+      scheduler.work
+      puts "rj_scheduler started."
+    end
+
+    task :stop do
+      pidfile = app_root.join('tmp/pids/rj_scheduler.pid')
+
+      unless File.exists?(pidfile)
+        msg = "Pidfile not found: #{pidfile}"
+        $stderr.puts msg
+        exit(1)
+      else
+        pid = open(pidfile).read.to_i
+        begin
+          Process.kill("TERM", pid)
+        rescue => e
+          $stderr.puts "Not found process: #{pid} from #{pidfile}"
+          $stderr.puts "Removing pidfile ..."
+          File.delete(pidfile) if File.exist?(pidfile)
+          exit(1)
+        end
+
+        while true
+          begin
+            Process.kill(0, pid)
+            sleep 0.1
+          rescue
+            puts "rj_scheduler[##{pid}] stopped."
+            exit(0)
+          end
+        end
+      end
+    end
+
+    task :status do
+      pidfile = app_root.join('tmp/pids/rj_scheduler.pid')
+
+      unless File.exists?(pidfile)
+        puts "Pidfile not found: #{pidfile}"
+        exit(1)
+      else
+        pid = open(pidfile).read.to_i
+        begin
+          raise "must return 1" unless Process.kill(0, pid) == 1
+          puts "ok"
+        rescue
+          puts "Pidfile found but process not respond: #{pidfile}"
+          puts "Removing pidfile."
+          File.delete(pidfile) if File.exist?(pidfile)
+          exit(1)
+        end
+      end
+      exit(0)
     end
   end
+
+  # desc "Start a Rabbit Jobs scheduler"
 end