blaxter-delayed_job 2.0.7 → 2.1.0

data/VERSION

@@ -1 +1 @@
-2.0.7
+2.1.0

data/lib/delayed/job.rb

@@ -24,7 +24,7 @@ module Delayed
     cattr_accessor :destroy_successful_jobs
     self.destroy_successful_jobs = false
 
-    NextTaskSQL         = '(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR (locked_by = ?)) AND failed_at IS NULL AND finished_at IS NULL'
+    NextTaskSQL         = '(run_at <= ? AND (locked_at IS NULL OR locked_at < ?)) AND failed_at IS NULL AND finished_at IS NULL'
     NextTaskOrder       = 'priority DESC, run_at ASC'
 
     ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
@@ -35,11 +35,24 @@ module Delayed
 
     class << self
       # When a worker is exiting, make sure we don't have any locked jobs.
-      def clear_locks!( worker_name )
+      def clear_locks!(worker_name)
         update_all("locked_by = null, locked_at = null", ["locked_by = ?", worker_name])
       end
 
-      # Add a job to the queue
+      # Unlock all jobs in the database, use careful!
+      def unlock_all!
+        unfinished.each do |job|
+          job.unlock
+          job.save!
+        end
+      end
+
+      # Add a job to the queue. Parameters (positional):
+      #    - job
+      #    - priority (default is 0)
+      #    - run_at (timestamp, default is right now)
+      # You could ignore the first parameter but including a block, which will
+      # be taken as the job to enqueue.
       def enqueue(*args, &block)
         object = block_given? ? EvaledJob.new(&block) : args.shift
 
@@ -53,15 +66,16 @@ module Delayed
         Job.create(:payload_object => object, :priority => priority.to_i, :run_at => run_at)
       end
 
-      # Conditions used for find_available method. This is in a separated method to be able to override
-      # (or method chain it) more easy so you can customize the behaviour of your workers.
+      # Conditions used for find_available method. This is in a separated method
+      # to be able to override (or method chain it) more easy so you can
+      # customize the behaviour of your workers.
       def conditions_available(options = {})
         max_run_time = options[:max_run_time] || MAX_RUN_TIME
         worker_name  = options[:worker_name]  || Worker::DEFAULT_WORKER_NAME
 
         sql        = NextTaskSQL.dup
         time_now   = db_time_now
-        conditions = [time_now, time_now - max_run_time, worker_name]
+        conditions = [time_now, time_now - max_run_time]
         if options[:min_priority]
           sql << ' AND (priority >= ?)'
           conditions << options[:min_priority]
@@ -104,7 +118,7 @@ module Delayed
         find_available( options ).each do |job|
           t = job.run_with_lock( max_run_time, worker_name )
           if t.nil?
-            Delayed::Worker.logger.info "* #{worker_name} No work done."
+            Delayed::Worker.logger.info "#{worker_name} No work done."
           else
             return t
           end
@@ -183,9 +197,9 @@ module Delayed
         save!
       else
         if self.attempts > 0
-          Delayed::Worker.logger.info "* [JOB] PERMANENTLY removing #{self.name} because of #{attempts} consequetive failures."
+          Delayed::Worker.logger.info "[JOB] PERMANENTLY removing #{name} because of #{attempts} consequetive failures."
         else
-          Delayed::Worker.logger.info "* [JOB] PERMANENTLY removing #{self.name} because no attempts for this job"
+          Delayed::Worker.logger.info "[JOB] PERMANENTLY removing #{name} because no attempts for this job"
         end
         if destroy_failed_jobs
           destroy
@@ -199,10 +213,9 @@ module Delayed
     # Try to run one job.
     # Returns true/false (work done/work failed) or nil if job can't be locked.
     def run_with_lock(max_run_time = MAX_RUN_TIME, worker_name = Worker::DEFAULT_WORKER_NAME)
-      Delayed::Worker.logger.info "* [JOB] #{worker_name} aquiring lock on #{name}"
       unless lock_exclusively!(max_run_time, worker_name)
         # We did not get the lock, some other worker process must have
-        Delayed::Worker.logger.warn "* [JOB] #{worker_name} - failed to aquire exclusive lock for #{name}"
+        Delayed::Worker.logger.warn "[JOB] failed to aquire exclusive lock for #{name}"
         return nil # no work done
       end
 
@@ -212,7 +225,7 @@ module Delayed
         end
         destroy_successful_jobs ? destroy :
           update_attribute(:finished_at, Time.now)
-        Delayed::Worker.logger.info "* [JOB] #{worker_name} -  #{name} completed after %.4f" % runtime
+        Delayed::Worker.logger.info "[JOB] #{name} completed after %.4f" % runtime
         return true  # did work
       rescue Exception => e
         reschedule e.message, e.backtrace
@@ -250,7 +263,7 @@ module Delayed
 
     # This is a good hook if you need to report job processing errors in additional or different ways
     def log_exception(error)
-      Delayed::Worker.logger.error "* [JOB] #{name} failed with #{error.class.name}: #{error.message} - #{attempts} failed attempts"
+      Delayed::Worker.logger.error "[JOB] #{name} failed with #{error.class.name}: #{error.message} - #{attempts} failed attempts"
       if Delayed::HIDE_BACKTRACE
         Delayed::Worker.logger.error error.to_s.split("\n").first
       else

data/lib/delayed/job_handler.rb

@@ -0,0 +1,129 @@
+# Handle asynchronously launch of jobs, one per grouped value
+#
+# It needs the following method to be defined:
+#    - name: return the name of the worker
+#    - group_by: return the method to be called to obtain the object
+#                needed to group jobs
+#    - log: log method
+#
+# Implements the following interface:
+#    - initialize_launcher(Fixnum max_allowed) (Must be called at beginning)
+#    - launch(Delayed::Job job) => bool (launched or not)
+#    - jobs_in_execution => Fixnum
+#    - report_jobs_state => prints info to stdout
+#    - check_thread_sanity => maintenance operation
+module Delayed
+  module JobLauncher
+    MAX_ACTIVE_JOBS = 50
+
+    # Initialize the launcher, you can specified the maximun number of
+    # jobs executing in parallel, by default MAX_ACTIVE_JOBS constant
+    #
+    # The launcher has a hash with the following structure:
+    # {}
+    #  |- id
+    #  |   `{}
+    #  |     |-:thread     => Thread
+    #  |     |-:job        => Delayed::Job
+    #  |     `-:started_at => Time
+    #  `-...
+    # If group_by specified an ActiveRecord::Base object, id will be the
+    # primary key of those objects.
+    def initialize_launcher(max_active_jobs=MAX_ACTIVE_JOBS)
+      @max_active_jobs = max_active_jobs
+      @jobs = {}
+    end
+
+    # Launch the job in a thread and register it. Returns whether the job
+    # has been launched or not.
+    def launch(job)
+      return false unless can_execute job
+      t = Thread.new do
+        begin
+          job.run_with_lock Job::MAX_RUN_TIME, name
+        ensure
+          unregister_job job
+        end
+      end
+      register_job job, t
+      return true
+    end
+
+    # Print information about the current state to stdout
+    def report_jobs_state
+      if jobs_in_execution > 0
+        margin = 20
+        title = "Jobs In Execution"
+        puts "\n #{'='*margin} #{title} #{'='*margin} "
+        puts " There are #{jobs_in_execution} jobs running."
+        each_job_in_execution do |job, started_at, thread|
+          duration = Duration.new(Time.now - started_at)
+          puts "\tJob #{job.id}: #{job}"
+          puts "\t   Running on #{thread} (#{thread.status}) for #{duration}"
+        end
+        puts " #{'=' * (margin * 2 + title + 2)} "
+      else
+        puts "\n\tThere is no jobs in execution right now!"
+      end
+    end
+
+    # Sanity check of dead threads for precaution, but probably won't be
+    # necessary
+    def check_thread_sanity
+      @jobs.values.each do |v|
+        thread = v[:thread]
+        unless thread.alive?
+          log "Dead thread? Terminate it!, This should not be happening"
+          thread.terminate
+        end
+      end
+    end
+
+    # Number of jobs executing right now
+    def jobs_in_execution
+      @jobs.size
+    end
+
+    # ^ public methods -------------------------------------------------------
+    private
+    # v private methods ------------------------------------------------------
+
+    # Whether we can or not execute this job
+    def can_execute(job)
+      object = get_object(job)
+      object && ! is_there_job_in_execution_for(object) &&
+        jobs_in_execution < @max_active_jobs
+    end
+
+    def each_job_in_execution
+      @jobs.each_pair do |key, value|
+        yield value[:job], value[:started_at], value[:thread]
+      end
+    end
+
+    def is_there_job_in_execution_for(o)
+      !! @jobs[o]
+    end
+
+    def unregister_job(job)
+      @jobs.delete get_object(job)
+    end
+
+    def register_job(job, thread)
+      @jobs[get_object(job)] = {
+        :thread     => thread,
+        :job        => job,
+        :started_at => Time.now
+      }
+    end
+
+    def get_object(job)
+      object = job.send group_by
+      if object.is_a? ActiveRecord::Base
+        object.id
+      else
+        object
+      end
+    end
+  end # module JobLauncher
+end # module Delayed

data/lib/delayed/worker.rb

@@ -3,8 +3,6 @@ module Delayed
 
   class Worker
     SLEEP = 5
-    JOBS_EACH = 100 # Jobs executed in each iteration
-
     DEFAULT_WORKER_NAME = "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
     # Indicates that we have catched a signal and we have to exit asap
     cattr_accessor :exit
@@ -17,11 +15,13 @@ module Delayed
       RAILS_DEFAULT_LOGGER
     end
 
-    # Every worker has a unique name which by default is the pid of the process (so you only are
-    # be able to have one unless override this in the constructor).
+    include JobLauncher
+
+    # Every worker has a unique name which by default is the pid of the process (so you should
+    # have only one unless override this in the constructor).
     #
-    #     Thread.new { Delayed::Worker.new( :name => "Worker 1" ).start }
-    #     Thread.new { Delayed::Worker.new( :name => "Worker 2" ).start }
+    #     Thread.new { Delayed::Worker.new(:name => "Worker 1").start }
+    #     Thread.new { Delayed::Worker.new(:name => "Worker 2").start }
     #
     # There are some advantages to overriding this with something which survives worker retarts:
     # Workers can safely resume working on tasks which are locked by themselves.
@@ -31,70 +31,117 @@ module Delayed
     # Constraints for this worker, what kind of jobs is gonna execute?
     attr_accessor :min_priority, :max_priority, :job_types, :only_for
 
+    # The jobs will be group by this attribute. Each delayed_job is gonna be executed must
+    # respond to `:group_by`. The jobs will be group by that and only one job can be in
+    # execution.
+    attr_accessor :group_by
+
+    # Whether log, also, to stdout or not
     attr_accessor :quiet
 
-    # A worker will be in a loop trying to execute pending jobs, you can also set
-    # a few constraints to customize the worker's behaviour.
-    #
-    # Named parameters:
-    #   - name: the name of the worker, mandatory if you are going to create several workers
-    #   - quiet: log to stdout (besides the normal logger)
-    #   - min_priority: constraint for selecting what jobs to execute (integer)
-    #   - max_priority: constraint for selecting what jobs to execute (integer)
-    #   - job_types: constraint for selecting what jobs to execute (String or Array)
+    # Seconds to sleep between each loop running available jobs
+    attr_accessor :sleep_time
+
+    # A worker will be in a loop trying to execute pending jobs looking in the database for that
     def initialize(options={})
-      [ :quiet, :name, :min_priority, :max_priority, :job_types, :only_for ].each do |attr_name|
+      [:quiet, :name, :min_priority, :max_priority, :job_types, :only_for, :group_by,
+       :sleep_time
+      ].each do |attr_name|
         send "#{attr_name}=", options.delete(attr_name)
       end
       # Default values
       self.name  = DEFAULT_WORKER_NAME if self.name.nil?
       self.quiet = true                if self.quiet.nil?
+      self.sleep_time = SLEEP          if self.sleep_time.nil?
+
       @options = options
+      initialize_launcher
     end
 
     def start
-      say "*** Starting job worker #{name}"
+      say "===> Starting job worker #{name}"
 
-      trap('TERM') { say 'Exiting...'; self.exit = true }
-      trap('INT')  { say 'Exiting...'; self.exit = true }
+      trap('TERM') { signal_interrupt }
+      trap('INT')  { signal_interrupt }
 
       loop do
-        result = nil
-
-        realtime = Benchmark.realtime do
-          result = Job.work_off constraints.merge(@options)
-        end
-
-        count = result.sum
-
-        if count.zero?
-          sleep(SLEEP) unless self.exit
+        if group_by
+          group_by_loop
         else
-          say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
+          normal_loop
         end
         break if self.exit
       end
-
     ensure
       Job.clear_locks! name
+      say "<=== Finishing job worker #{name}"
+    end
+
+    def jobs_to_execute
+      Job.find_available constraints
     end
 
     def say(text)
-      text = "#{name}: #{text}"
       puts text unless self.quiet
       logger.info text if logger
     end
+    alias :log :say
 
     protected
-      def constraints
-        { :max_run_time => Job::MAX_RUN_TIME,
-          :worker_name  => name,
-          :n            => JOBS_EACH,
-          :limit        => 5,
-          :min_priority => min_priority,
-          :max_priority => max_priority,
-          :only_for     => only_for,
-          :job_types    => job_types }
+
+    def signal_interrupt
+      if @signal && Time.now - @signal <= 1
+        @signal = Time.now
+        report_jobs_state
+        return
+      else
+        now = Time.now
+        @signal = now
+        sleep 1
+        return if @signal != now
+      end
+      say 'Exiting...'
+      self.exit = true
+    end
+
+    def sleep_for_a_little_while
+      sleep(sleep_time.to_i) unless self.exit
+    end
+
+    def group_by_loop
+      check_thread_sanity
+      jobs_to_execute.each do |job|
+        if launch job
+          log "Launched job #{job.name}, there are #{jobs_in_execution} jobs in execution"
+        end
       end
+      sleep_for_a_little_while
+    end
+
+    def normal_loop
+      result = nil
+
+      realtime = Benchmark.realtime do
+        result = Job.work_off constraints
+      end
+
+      count = result.sum
+
+      if count.zero?
+        sleep_for_a_little_while
+      else
+        say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
+      end
+    end
+
+    def constraints
+      {:max_run_time => Job::MAX_RUN_TIME,
+       :worker_name  => name,
+       :limit        => 5,
+       :min_priority => min_priority,
+       :max_priority => max_priority,
+       :only_for     => only_for,
+       :job_types    => job_types }.merge @options
+    end
   end
 end

data/lib/delayed_job.rb

@@ -2,6 +2,7 @@ autoload :ActiveRecord, 'activerecord'
 
 require File.dirname(__FILE__) + '/delayed/message_sending'
 require File.dirname(__FILE__) + '/delayed/performable_method'
+require File.dirname(__FILE__) + '/delayed/job_handler'
 require File.dirname(__FILE__) + '/delayed/job'
 require File.dirname(__FILE__) + '/delayed/worker'
 

data/spec/job_spec.rb

@@ -428,10 +428,10 @@ describe Delayed::Job do
       SimpleJob.runs.should == 1 # runs the one open job
     end
 
-    it "should find our own jobs regardless of locks" do
+    it "should find only ur own jobs unless they are locked" do
       SimpleJob.runs.should == 0
       Delayed::Job.work_off :worker_name => 'worker1'
-      SimpleJob.runs.should == 3 # runs open job plus worker1 jobs that were already locked
+      SimpleJob.runs.should == 1 # runs open job, no worker1 jobs that were already locked
     end
   end
 
@@ -453,9 +453,7 @@ describe Delayed::Job do
     it "should ignore locks when finding our own jobs" do
       SimpleJob.runs.should == 0
       Delayed::Job.work_off :worker_name => 'worker1'
-      SimpleJob.runs.should == 3 # runs open job plus worker1 jobs
-      # This is useful in the case of a crash/restart on worker1,
-      # but make sure multiple workers on the same host have unique names!
+      SimpleJob.runs.should == 2 # runs open job plus worker1 jobs (unless locked)
     end
 
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: blaxter-delayed_job
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 11
   prerelease: false
   segments: 
   - 2
+  - 1
   - 0
-  - 7
-  version: 2.0.7
+  version: 2.1.0
 platform: ruby
 authors: 
 - "Tobias L\xC3\xBCtke"
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-20 00:00:00 +02:00
+date: 2010-09-16 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,7 @@ files:
 - generators/delayed_job/templates/migration.rb
 - init.rb
 - lib/delayed/job.rb
+- lib/delayed/job_handler.rb
 - lib/delayed/message_sending.rb
 - lib/delayed/performable_method.rb
 - lib/delayed/worker.rb