rufus-scheduler 3.4.2 → 3.7.0

data/lib/rufus/scheduler/job_array.rb

@@ -1,72 +1,62 @@
 
-module Rufus
+#
+# The array rufus-scheduler uses to keep jobs in order (next to trigger
+# first).
+#
+class Rufus::Scheduler::JobArray
 
-  class Scheduler
+  def initialize
 
-    #
-    # The array rufus-scheduler uses to keep jobs in order (next to trigger
-    # first).
-    #
-    class JobArray
-
-      def initialize
-
-        @mutex = Mutex.new
-        @array = []
-      end
-
-      def push(job)
+    @mutex = Mutex.new
+    @array = []
+  end
 
-        @mutex.synchronize { @array << job unless @array.index(job) }
+  def push(job)
 
-        self
-      end
+    @mutex.synchronize { @array << job unless @array.index(job) }
 
-      def size
+    self
+  end
 
-        @array.size
-      end
+  def size
 
-      def each(now, &block)
+    @array.size
+  end
 
-        to_a.sort_by do |job|
+  def each(now, &block)
 
-          job.next_time || (now + 1)
+    to_a.sort_by do |job|
 
-        end.each do |job|
+      job.next_time || (now + 1)
 
-          nt = job.next_time
-          break if ( ! nt) || (nt > now)
+    end.each do |job|
 
-          block.call(job)
-        end
-      end
+      nt = job.next_time
+      break if ( ! nt) || (nt > now)
 
-      def delete_unscheduled
+      block.call(job)
+    end
+  end
 
-        @mutex.synchronize {
+  def delete_unscheduled
 
-          @array.delete_if { |j| j.next_time.nil? || j.unscheduled_at }
-        }
-      end
+    @mutex.synchronize {
+      @array.delete_if { |j| j.next_time.nil? || j.unscheduled_at } }
+  end
 
-      def to_a
+  def to_a
 
-        @mutex.synchronize { @array.dup }
-      end
+    @mutex.synchronize { @array.dup }
+  end
 
-      def [](job_id)
+  def [](job_id)
 
-        @mutex.synchronize { @array.find { |j| j.job_id == job_id } }
-      end
+    @mutex.synchronize { @array.find { |j| j.job_id == job_id } }
+  end
 
-      # Only used when shutting down, directly yields the underlying array.
-      #
-      def array
+  def unschedule_all
 
-        @array
-      end
-    end
+    @array.each(&:unschedule)
   end
 end
 

data/lib/rufus/scheduler/jobs_core.rb

@@ -0,0 +1,363 @@
+
+class Rufus::Scheduler::Job
+
+  EoTime = ::EtOrbi::EoTime
+
+  #
+  # Used by Job#kill
+  #
+  class KillSignal < StandardError; end
+
+  attr_reader :id
+  attr_reader :opts
+  attr_reader :original
+  attr_reader :scheduled_at
+  attr_reader :last_time
+  attr_reader :unscheduled_at
+  attr_reader :tags
+  attr_reader :locals
+  attr_reader :count
+  attr_reader :last_work_time
+  attr_reader :mean_work_time
+
+  attr_accessor :name
+
+  # next trigger time
+  #
+  attr_accessor :next_time
+
+  # previous "next trigger time"
+  #
+  attr_accessor :previous_time
+
+  # anything with a #call(job[, timet]) method,
+  # what gets actually triggered
+  #
+  attr_reader :callable
+
+  # a reference to the instance whose call method is the @callable
+  #
+  attr_reader :handler
+
+  # Default, core, implementation has no effect. Repeat jobs do override it.
+  #
+  def resume_discard_past=(v); end
+
+  def initialize(scheduler, original, opts, block)
+
+    @scheduler = scheduler
+    @original = original
+    @opts = opts
+
+    @handler = block
+
+    @callable =
+      if block.respond_to?(:arity)
+        block
+      elsif block.respond_to?(:call)
+        block.method(:call)
+      elsif block.is_a?(Class)
+        @handler = block.new
+        @handler.method(:call) rescue nil
+      else
+        nil
+      end
+
+    @scheduled_at = EoTime.now
+    @unscheduled_at = nil
+    @last_time = nil
+
+    @locals = opts[:locals] || opts[:l] || {}
+    @local_mutex = Mutex.new
+
+    @id = determine_id
+    @name = opts[:name] || opts[:n]
+
+    fail(
+      ArgumentError,
+      'missing block or callable to schedule',
+      caller[2..-1]
+    ) unless @callable
+
+    @tags = Array(opts[:tag] || opts[:tags]).collect { |t| t.to_s }
+
+    @count = 0
+    @last_work_time = 0.0
+    @mean_work_time = 0.0
+
+    # tidy up options
+
+    if @opts[:allow_overlap] == false || @opts[:allow_overlapping] == false
+      @opts[:overlap] = false
+    end
+    if m = @opts[:mutex]
+      @opts[:mutex] = Array(m)
+    end
+  end
+
+  alias job_id id
+
+  # Will fail with an ArgumentError if the job frequency is higher than
+  # the scheduler frequency.
+  #
+  def check_frequency
+
+    # this parent implementation never fails
+  end
+
+  def trigger(time)
+
+    @previous_time = @next_time
+    set_next_time(time)
+
+    do_trigger(time)
+  end
+
+  # Trigger the job right now, off of its schedule.
+  #
+  # Done in collaboration with Piavka in
+  # https://github.com/jmettraux/rufus-scheduler/issues/214
+  #
+  def trigger_off_schedule(time=EoTime.now)
+
+    do_trigger(time)
+  end
+
+  def unschedule
+
+    @unscheduled_at = EoTime.now
+  end
+
+  def threads
+
+    Thread.list.select { |t| t[:rufus_scheduler_job] == self }
+  end
+
+  # Kills all the threads this Job currently has going on.
+  #
+  def kill
+
+    threads.each { |t| t.raise(KillSignal) }
+  end
+
+  def running?
+
+    threads.any?
+  end
+
+  def scheduled?
+
+    @scheduler.scheduled?(self)
+  end
+
+  def []=(key, value)
+
+    @local_mutex.synchronize { @locals[key] = value }
+  end
+
+  def [](key)
+
+    @local_mutex.synchronize { @locals[key] }
+  end
+
+  def has_key?(key)
+
+    @local_mutex.synchronize { @locals.has_key?(key) }
+  end
+  alias key? has_key?
+
+  def keys; @local_mutex.synchronize { @locals.keys }; end
+  def values; @local_mutex.synchronize { @locals.values }; end
+  def entries; @local_mutex.synchronize { @locals.entries }; end
+
+  #def hash
+  #  self.object_id
+  #end
+  #def eql?(o)
+  #  o.class == self.class && o.hash == self.hash
+  #end
+    #
+    # might be necessary at some point
+
+  def next_times(count)
+
+    next_time ? [ next_time ] : []
+  end
+
+  # Calls the callable (usually a block) wrapped in this Job instance.
+  #
+  # Warning: error rescueing is the responsibity of the caller.
+  #
+  def call(do_rescue=false)
+
+    do_call(EoTime.now, do_rescue)
+  end
+
+  protected
+
+  def callback(meth, time)
+
+    return true unless @scheduler.respond_to?(meth)
+
+    arity = @scheduler.method(meth).arity
+    args = [ self, time ][0, (arity < 0 ? 2 : arity)]
+
+    @scheduler.send(meth, *args)
+  end
+
+  def compute_timeout
+
+    if to = @opts[:timeout]
+      Rufus::Scheduler.parse(to)
+    else
+      nil
+    end
+  end
+
+  def mutex(m)
+
+    m.is_a?(Mutex) ? m : (@scheduler.mutexes[m.to_s] ||= Mutex.new)
+  end
+
+  def do_call(time, do_rescue)
+
+    args = [ self, time ][0, @callable.arity]
+
+    @scheduler.around_trigger(self) do
+      @callable.call(*args)
+    end
+
+  rescue StandardError => se
+
+    fail se unless do_rescue
+
+    return if se.is_a?(KillSignal) # discard
+
+    @scheduler.on_error(self, se)
+
+  # exceptions above StandardError do pass through
+  end
+
+  def do_trigger(time)
+
+    return if (
+      opts[:overlap] == false &&
+      running?
+    )
+    return if (
+      callback(:confirm_lock, time) &&
+      callback(:on_pre_trigger, time)
+    ) == false
+
+    @count += 1
+
+    if opts[:blocking]
+      trigger_now(time)
+    else
+      trigger_queue(time)
+    end
+  end
+
+  def trigger_now(time)
+
+    ct = Thread.current
+
+    t = EoTime.now
+      # if there are mutexes, t might be really bigger than time
+
+    ct[:rufus_scheduler_job] = self
+    ct[:rufus_scheduler_time] = t
+    ct[:rufus_scheduler_timeout] = compute_timeout
+
+    @last_time = t
+
+    do_call(time, true)
+
+  ensure
+
+    @last_work_time =
+      EoTime.now - ct[:rufus_scheduler_time]
+    @mean_work_time =
+      ((@count - 1) * @mean_work_time + @last_work_time) / @count
+
+    post_trigger(time)
+
+    ct[:rufus_scheduler_job] = nil
+    ct[:rufus_scheduler_time] = nil
+    ct[:rufus_scheduler_timeout] = nil
+  end
+
+  def post_trigger(time)
+
+    set_next_time(time, true)
+      # except IntervalJob instances, jobs will ignore this call
+
+    callback(:on_post_trigger, time)
+  end
+
+  def start_work_thread
+
+    thread =
+      Thread.new do
+
+        ct = Thread.current
+
+        ct[:rufus_scheduler_job] = true
+          # indicates that the thread is going to be assigned immediately
+
+        ct[@scheduler.thread_key] = true
+        ct[:rufus_scheduler_work_thread] = true
+
+        loop do
+
+          break if @scheduler.started_at == nil
+
+          job, time = @scheduler.work_queue.pop
+
+          break if job == :shutdown
+          break if @scheduler.started_at == nil
+
+          next if job.unscheduled_at
+
+          begin
+
+            (job.opts[:mutex] || []).reduce(
+              lambda { job.trigger_now(time) }
+            ) do |b, m|
+              lambda { mutex(m).synchronize { b.call } }
+            end.call
+
+          rescue KillSignal
+
+            # simply go on looping
+          end
+        end
+      end
+
+    thread[@scheduler.thread_key] = true
+    thread[:rufus_scheduler_work_thread] = true
+      #
+      # same as above (in the thead block),
+      # but since it has to be done as quickly as possible.
+      # So, whoever is running first (scheduler thread vs job thread)
+      # sets this information
+
+    thread
+  end
+
+  def trigger_queue(time)
+
+    threads = @scheduler.work_threads
+
+    vac = threads.select { |t| t[:rufus_scheduler_job] == nil }.size
+    que = @scheduler.work_queue.size
+
+    cur = threads.size
+    max = @scheduler.max_work_threads
+
+    start_work_thread if vac - que < 1 && cur < max
+
+    @scheduler.work_queue << [ self, time ]
+  end
+end
+