rufus-scheduler 1.0.14 → 2.0.0

data/TODO.txt

@@ -0,0 +1,51 @@
+
+[o] spec for jobs in the past (in and at)
+[o] :discard_past
+
+[o] every
+[o] cron
+
+[o] CHECK every and unschedule !!!
+
+[o] :tags
+[o] timeout feature (at/in/every/cron) in Job class
+
+[o] :first_in, :first_at
+
+[x] :dont_reschedule (or block returns false ?)
+
+[o] [get_]jobs methods
+[o] find methods
+
+[x] CTRL-C during tests : allow, trap_int...
+
+[o] 1.9
+[o] j1.2.0
+
+[o] revise trigger block arity
+    use a compatibility switch ? yes
+
+[o] synchronize @cron_jobs ?
+
+[o] why not : make it work even if EM is not present
+    EmScheduler < Scheduler
+    FiberScheduler < Scheduler
+
+[x] :blocking => 'blockname' idea, mutex = @mutexes['blockname'] ...
+[o] eventually, make sleep frequency customizable
+
+[o] PlainScheduler : name thread
+
+[o] document :blocking
+
+[o] README.rdoc
+[o] fix jruby120 --em
+
+[o] handle_exception (job, e)
+
+[o] Schedulable
+
+[o] Rufus::Scheduler.start_new() : autodetect EM ?
+[o] check :blocking and every (reschedule blocking...)
+[o] document :thread_name scheduler option
+

data/lib/rufus-scheduler.rb

@@ -1,3 +1,3 @@
 
-require 'rufus/scheduler/scheduler'
+require 'rufus/sc/scheduler'
 

data/lib/rufus/otime.rb

@@ -1,3 +1,3 @@
 
-require 'rufus/scheduler/otime'
+require 'rufus/sc/rtime.rb'
 

data/lib/rufus/{scheduler → sc}/cronline.rb

@@ -52,45 +52,34 @@ module Rufus
 
       items = line.split
 
-      unless [ 5, 6 ].include?(items.length)
-        raise \
-          "cron '#{line}' string should hold 5 or 6 items, " +
-          "not #{items.length}" \
+      unless items.length == 5 or items.length == 6
+        raise(
+          "cron '#{line}' string should hold 5 or 6 items, not #{items.length}")
       end
 
       offset = items.length - 5
 
-      @seconds = if offset == 1
-        parse_item(items[0], 0, 59)
-      else
-        [ 0 ]
-      end
-      @minutes = parse_item(items[0+offset], 0, 59)
-      @hours = parse_item(items[1+offset], 0, 24)
-      @days = parse_item(items[2+offset], 1, 31)
-      @months = parse_item(items[3+offset], 1, 12)
-      @weekdays = parse_weekdays(items[4+offset])
-
-      #adjust_arrays()
+      @seconds = offset == 1 ? parse_item(items[0], 0, 59) : [ 0 ]
+      @minutes = parse_item(items[0 + offset], 0, 59)
+      @hours = parse_item(items[1 + offset], 0, 24)
+      @days = parse_item(items[2 + offset], 1, 31)
+      @months = parse_item(items[3 + offset], 1, 12)
+      @weekdays = parse_weekdays(items[4 + offset])
     end
 
     #
     # Returns true if the given time matches this cron line.
     #
-    # (the precision is passed as well to determine if it's
-    # worth checking seconds and minutes)
-    #
     def matches? (time)
-    #def matches? (time, precision)
 
       time = Time.at(time) unless time.kind_of?(Time)
 
-      return false unless sub_match? time.sec,   @seconds
-      return false unless sub_match? time.min,   @minutes
-      return false unless sub_match? time.hour,  @hours
-      return false unless sub_match? time.day,   @days
-      return false unless sub_match? time.month, @months
-      return false unless sub_match? time.wday,  @weekdays
+      return false unless sub_match?(time.sec, @seconds)
+      return false unless sub_match?(time.min, @minutes)
+      return false unless sub_match?(time.hour, @hours)
+      return false unless sub_match?(time.day, @days)
+      return false unless sub_match?(time.month, @months)
+      return false unless sub_match?(time.wday, @weekdays)
       true
     end
 
@@ -128,27 +117,29 @@ module Rufus
     #
     # (Thanks to K Liu for the note and the examples)
     #
-    def next_time time=Time.now
+    def next_time (time=Time.now)
+
       time -= time.usec * 1e-6
       time += 1
 
       loop do
-        unless date_match? time
+
+        unless date_match?(time)
           time += (24 - time.hour) * 3600 - time.min * 60 - time.sec
           next
         end
 
-        unless sub_match? time.hour, @hours
+        unless sub_match?(time.hour, @hours)
           time += (60 - time.min) * 60 - time.sec
           next
         end
 
-        unless sub_match? time.min, @minutes
+        unless sub_match?(time.min, @minutes)
           time += 60 - time.sec
           next
         end
 
-        unless sub_match? time.sec, @seconds
+        unless sub_match?(time.sec, @seconds)
           time += 1
           next
         end
@@ -161,25 +152,6 @@ module Rufus
 
     private
 
-    #--
-    # adjust values to Ruby
-    #
-    #def adjust_arrays()
-    #  @hours = @hours.collect { |h|
-    #    if h == 24
-    #      0
-    #    else
-    #      h
-    #    end
-    #  } if @hours
-    #  @weekdays = @weekdays.collect { |wd|
-    #    wd - 1
-    #  } if @weekdays
-    #end
-      #
-      # dead code, keeping it as a reminder
-    #++
-
     WDS = %w[ sun mon tue wed thu fri sat ]
       #
       # used by parse_weekday()
@@ -188,25 +160,20 @@ module Rufus
 
       item = item.downcase
 
-      WDS.each_with_index do |day, index|
-        item = item.gsub day, "#{index}"
-      end
-
-      r = parse_item item, 0, 7
+      WDS.each_with_index { |day, index| item = item.gsub(day, index.to_s) }
 
-      return r unless r.is_a?(Array)
+      r = parse_item(item, 0, 7)
 
-      r.collect { |e| e == 7 ? 0 : e }.uniq
+      r.is_a?(Array) ?
+        r.collect { |e| e == 7 ? 0 : e }.uniq :
+        r
     end
 
     def parse_item (item, min, max)
 
-      return nil \
-        if item == "*"
-      return parse_list(item, min, max) \
-        if item.index(",")
-      return parse_range(item, min, max) \
-        if item.index("*") or item.index("-")
+      return nil if item == '*'
+      return parse_list(item, min, max) if item.index(',')
+      return parse_range(item, min, max) if item.index('*') or item.index('-')
 
       i = Integer(item)
 
@@ -218,33 +185,31 @@ module Rufus
 
     def parse_list (item, min, max)
 
-      items = item.split(",")
-
-      items.inject([]) { |r, i| r.push(parse_range(i, min, max)) }.flatten
+      item.split(',').inject([]) { |r, i|
+        r.push(parse_range(i, min, max))
+      }.flatten
     end
 
     def parse_range (item, min, max)
 
-      i = item.index("-")
-      j = item.index("/")
+      i = item.index('-')
+      j = item.index('/')
 
       return item.to_i if (not i and not j)
 
-      inc = 1
-
-      inc = Integer(item[j+1..-1]) if j
+      inc = j ? Integer(item[j+1..-1]) : 1
 
       istart = -1
       iend = -1
 
       if i
 
-        istart = Integer(item[0..i-1])
+        istart = Integer(item[0..i - 1])
 
         if j
-          iend = Integer(item[i+1..j])
+          iend = Integer(item[i + 1..j])
         else
-          iend = Integer(item[i+1..-1])
+          iend = Integer(item[i + 1..-1])
         end
 
       else # case */x
@@ -260,7 +225,6 @@ module Rufus
 
       value = istart
       loop do
-
         result << value
         value = value + inc
         break if value > iend
@@ -269,14 +233,14 @@ module Rufus
       result
     end
 
-    def sub_match? value, values
+    def sub_match?(value, values)
       values.nil? || values.include?(value)
     end
 
-    def date_match? date
-      return false unless sub_match? date.day,   @days
-      return false unless sub_match? date.month, @months
-      return false unless sub_match? date.wday,  @weekdays
+    def date_match?(date)
+      return false unless sub_match?(date.day, @days)
+      return false unless sub_match?(date.month, @months)
+      return false unless sub_match?(date.wday, @weekdays)
       true
     end
   end

data/lib/rufus/sc/jobqueues.rb

@@ -0,0 +1,157 @@
+#--
+# Copyright (c) 2006-2009, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+require 'thread'
+
+
+module Rufus
+module Scheduler
+
+  #
+  # Tracking at/in/every jobs.
+  #
+  # In order of trigger time.
+  #
+  class JobQueue
+
+    # Mapping :at|:in|:every to their respective job classes.
+    #
+    JOB_TYPES = {
+      :at => Rufus::Scheduler::AtJob,
+      :in => Rufus::Scheduler::InJob,
+      :every => Rufus::Scheduler::EveryJob
+    }
+
+    def initialize
+
+      @mutex = Mutex.new
+      @jobs = []
+    end
+
+    # Returns the next job to trigger. Returns nil if none eligible.
+    #
+    def job_to_trigger
+
+      @mutex.synchronize do
+        if @jobs.size > 0 && Time.now.to_f >= @jobs.first.at
+          @jobs.shift
+        else
+          nil
+        end
+      end
+    end
+
+    # Adds this job to the map.
+    #
+    def << (job)
+
+      @mutex.synchronize do
+        delete(job.job_id)
+        @jobs << job
+        @jobs.sort! { |j0, j1| j0.at <=> j1.at }
+      end
+    end
+
+    # Removes a job (given its id). Returns nil if the job was not found.
+    #
+    def unschedule (job_id)
+
+      @mutex.synchronize { delete(job_id) }
+    end
+
+    # Returns a mapping job_id => job
+    #
+    def to_h
+
+      @jobs.inject({}) { |h, j| h[j.job_id] = j; h }
+    end
+
+    # Returns a list of jobs of the given type (:at|:in|:every)
+    #
+    def select (type)
+
+      type = JOB_TYPES[type]
+      @jobs.select { |j| j.is_a?(type) }
+    end
+
+    def size
+
+      @jobs.size
+    end
+
+    protected
+
+    def delete (job_id)
+      j = @jobs.find { |j| j.job_id == job_id }
+      @jobs.delete(j) if j
+      j
+    end
+  end
+
+  #
+  # Tracking cron jobs.
+  #
+  # (mostly synchronizing access to the map of cron jobs)
+  #
+  class CronJobQueue
+
+    def initialize
+
+      @mutex = Mutex.new
+      @jobs = {}
+    end
+
+    def unschedule (job_id)
+
+      @mutex.synchronize { @jobs.delete(job_id) }
+    end
+
+    def trigger_matching_jobs (now)
+
+      js = @mutex.synchronize { @jobs.values }
+        # maybe this sync is a bit paranoid
+
+      js.each { |job| job.trigger_if_matches(now) }
+    end
+
+    def << (job)
+
+      @mutex.synchronize { @jobs[job.job_id] = job }
+    end
+
+    def size
+
+      @jobs.size
+    end
+
+    def to_h
+
+      @jobs.dup
+    end
+  end
+
+end
+end
+

data/lib/rufus/sc/jobs.rb

@@ -0,0 +1,339 @@
+#--
+# Copyright (c) 2006-2009, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Rufus
+module Scheduler
+
+  #
+  # The base class for all types of jobs.
+  #
+  class Job
+
+    # A reference to the scheduler owning this job
+    #
+    attr_reader :scheduler
+
+    # The initial, raw, scheduling info (at / in / every / cron)
+    #
+    attr_reader :t
+
+    # When the job is actually running, this attribute will hold the
+    # thread in which the job is running.
+    # Can be used to determine if a job is actually running.
+    #
+    attr_reader :job_thread
+
+    # The job parameters (passed via the schedule method)
+    #
+    attr_reader :params
+
+    # The block to call when triggering
+    #
+    attr_reader :block
+
+    # Last time the job executed
+    # (for an {At|In}Job, it will mean 'not executed' if nil or when
+    # it got executed if set)
+    #
+    # (
+    # Last time job got triggered (most useful with EveryJob, but can be
+    # useful with remaining instances of At/InJob (are they done ?))
+    # )
+    #
+    attr_reader :last
+
+    # The identifier for this job.
+    #
+    attr_reader :job_id
+
+
+    # Instantiating the job.
+    #
+    def initialize (scheduler, t, params, &block)
+
+      @scheduler = scheduler
+      @t = t
+      @params = params
+      @block = block || params[:schedulable]
+
+      raise ArgumentError.new(
+        'no block or :schedulable passed, nothing to schedule'
+      ) unless @block
+
+      @params[:tags] = Array(@params[:tags])
+
+      @job_id = params[:job_id] || "#{self.class.name}_#{self.object_id.to_s}"
+
+      determine_at
+    end
+
+    # Returns the list of tags attached to the job.
+    #
+    def tags
+
+      @params[:tags]
+    end
+
+    # Sets the list of tags attached to the job (Usually they are set
+    # via the schedule every/at/in/cron method).
+    #
+    def tags= (tags)
+
+      @params[:tags] = Array(tags)
+    end
+
+    # Generally returns the string/float/integer used to schedule the job
+    # (seconds, time string, date string)
+    #
+    def schedule_info
+
+      @t
+    end
+
+    # Triggers the job.
+    #
+    def trigger (t=Time.now)
+
+      @last = t
+
+      @scheduler.send(:trigger_job, @params[:blocking]) do
+        #
+        # Note that #trigger_job is protected, hence the #send
+        # (Only jobs know about this method of the scheduler)
+
+        @job_thread = Thread.current
+
+        begin
+
+          #args = prepare_args
+          #@block.call(*args)
+
+          #@block.call(self)
+
+          @block.respond_to?(:call) ?
+            @block.call(self) : @block.trigger(@params)
+
+          @job_thread = nil
+
+        rescue Exception => e
+
+          @scheduler.handle_exception(self, e)
+        end
+      end
+
+      # note that add_job and add_cron_job ensured that :blocking is
+      # not used along :timeout
+
+      if to = @params[:timeout]
+
+        @scheduler.in(to, :tags => 'timeout') do
+
+          # at this point, @job_thread might be set
+
+          @job_thread.raise(Rufus::Scheduler::TimeOutError) \
+            if @job_thread and @job_thread.alive?
+        end
+      end
+    end
+
+    # Unschedules this job.
+    #
+    def unschedule
+
+      @scheduler.unschedule(self.job_id)
+    end
+
+    #--
+    #protected
+    #
+    # Prepare the args given the triggered block arity.
+    #
+    #def prepare_args
+    #  if @scheduler.options[:onezero_block_arity]
+    #    case @block.arity
+    #      when 0 then []
+    #      when 1 then [ @params ]
+    #      when 2 then [ @job_id, @params ]
+    #      #else [ @job_id, schedule_info, @params ]
+    #      else [ @job_id, self, @params ]
+    #    end
+    #  else
+    #    [ self ]
+    #  end
+    #end
+    #++
+  end
+
+  #
+  # The base class of at/in/every jobs.
+  #
+  class SimpleJob < Job
+
+    # When the job is supposed to trigger
+    #
+    attr_reader :at
+
+    attr_reader :last
+
+    def determine_at
+
+      @at = Rufus.at_to_f(@t)
+    end
+  end
+
+  #
+  # Job that occurs once, in a certain amount of time.
+  #
+  class InJob < SimpleJob
+
+    protected
+
+    def determine_at
+
+      iin = @t.is_a?(Fixnum) || @t.is_a?(Float) ?
+        @t : Rufus.parse_duration_string(@t)
+
+      @at = (Time.now + iin).to_f
+    end
+  end
+
+  #
+  # Job that occurs once, at a certain point in time.
+  #
+  class AtJob < SimpleJob
+  end
+
+  #
+  # Recurring job with a certain frequency.
+  #
+  class EveryJob < SimpleJob
+
+    # The frequency, in seconds, of this EveryJob
+    #
+    attr_reader :frequency
+
+    def initialize (scheduler, t, params, &block)
+      super
+      determine_frequency
+      determine_at
+    end
+
+    # Triggers the job (and reschedules it).
+    #
+    def trigger
+
+      schedule_next
+
+      super
+
+      #unschedule if @params[:dont_reschedule]
+        # obsolete
+    end
+
+    protected
+
+    def determine_frequency
+
+      @frequency = @t.is_a?(Fixnum) || @t.is_a?(Float) ?
+        @t : Rufus.parse_duration_string(@t)
+    end
+
+    def determine_at
+
+      return unless @frequency
+
+      @last = @at
+        # the first time, @last will be nil
+
+      @at = if @last
+        @last + @frequency
+      else
+        if fi = @params[:first_in]
+          Time.now.to_f + Rufus.duration_to_f(fi)
+        elsif fa = @params[:first_at]
+          Rufus.at_to_f(fa)
+        else
+          Time.now.to_f + @frequency
+        end
+      end
+    end
+
+    # It's an every job, have to schedule next time it occurs...
+    #
+    def schedule_next
+
+      determine_at
+
+      @scheduler.send(:add_job, self)
+    end
+  end
+
+  #
+  # Recurring job, cron style.
+  #
+  class CronJob < Job
+
+    # The CronLine instance, it holds all the info about the cron schedule
+    #
+    attr_reader :cron_line
+
+    # The job parameters (passed via the schedule method)
+    #
+    attr_reader :params
+
+    # The block to call when triggering
+    #
+    attr_reader :block
+
+    # Creates a new CronJob instance.
+    #
+    def initialize (scheduler, cron_string, params, &block)
+
+      super
+
+      @cron_line = case @t
+
+        when String then CronLine.new(@t)
+        when CronLine then @t
+
+        else raise "cannot initialize a CronJob out of #{@t.inspect}"
+      end
+    end
+
+    def trigger_if_matches (time)
+
+      trigger(time) if @cron_line.matches?(time)
+    end
+
+    protected
+
+    def determine_at
+      # empty
+    end
+  end
+
+end
+end
+