rufus-scheduler 3.0.0 → 3.0.9

data/lib/rufus/scheduler/cronline.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2013, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2014, 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
@@ -106,15 +106,15 @@ class Rufus::Scheduler
     # be passed if no start time is specified (search start time set to
     # Time.now))
     #
-    #   Rufus::CronLine.new('30 7 * * *').next_time(
+    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
     #     Time.mktime(2008, 10, 24, 7, 29))
     #   #=> Fri Oct 24 07:30:00 -0500 2008
     #
-    #   Rufus::CronLine.new('30 7 * * *').next_time(
+    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
     #     Time.utc(2008, 10, 24, 7, 29))
     #   #=> Fri Oct 24 07:30:00 UTC 2008
     #
-    #   Rufus::CronLine.new('30 7 * * *').next_time(
+    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
     #     Time.utc(2008, 10, 24, 7, 29)).localtime
     #   #=> Fri Oct 24 02:30:00 -0500 2008
     #
@@ -122,18 +122,18 @@ class Rufus::Scheduler
     #
     def next_time(from=Time.now)
 
-      time = @timezone ? @timezone.utc_to_local(from.getutc) : from
-
-      time = time.respond_to?(:round) ? time.round : time - time.usec * 1e-6
-        # chop off subseconds (and yes, Ruby 1.8 doesn't have #round)
+      time = local_time(from)
+      time = round_to_seconds(time)
 
+      # start at the next second
       time = time + 1
-        # start at the next second
 
       loop do
-
         unless date_match?(time)
-          time += (24 - time.hour) * 3600 - time.min * 60 - time.sec; next
+          dst = time.isdst
+          time += (24 - time.hour) * 3600 - time.min * 60 - time.sec
+          time -= 3600 if time.isdst != dst # not necessary for winter, but...
+          next
         end
         unless sub_match?(time, :hour, @hours)
           time += (60 - time.min) * 60 - time.sec; next
@@ -148,34 +148,46 @@ class Rufus::Scheduler
         break
       end
 
-      if @timezone
-        time = @timezone.local_to_utc(time)
-        time = time.getlocal unless from.utc?
-      end
+      global_time(time, from.utc?)
 
-      time
+    rescue TZInfo::PeriodNotFound
+
+      next_time(from + 3600)
     end
 
-    # Returns the previous the cronline matched. It's like next_time, but
+    # Returns the previous time the cronline matched. It's like next_time, but
     # for the past.
     #
     def previous_time(from=Time.now)
 
-      # looks back by slices of two hours,
-      #
-      # finds for '* * * * sun', '* * 13 * *' and '0 12 13 * *'
-      # starting 1970, 1, 1 in 1.8 to 2 seconds (says Rspec)
+      time = local_time(from)
+      time = round_to_seconds(time)
 
-      start = current = from - 2 * 3600
-      result = nil
+      # start at the previous second
+      time = time - 1
 
       loop do
-        nex = next_time(current)
-        return (result ? result : previous_time(start)) if nex > from
-        result = current = nex
+        unless date_match?(time)
+          time -= time.hour * 3600 + time.min * 60 + time.sec + 1; next
+        end
+        unless sub_match?(time, :hour, @hours)
+          time -= time.min * 60 + time.sec + 1; next
+        end
+        unless sub_match?(time, :min, @minutes)
+          time -= time.sec + 1; next
+        end
+        unless sub_match?(time, :sec, @seconds)
+          time -= 1; next
+        end
+
+        break
       end
 
-      # never reached
+      global_time(time, from.utc?)
+
+    rescue TZInfo::PeriodNotFound
+
+      previous_time(time)
     end
 
     # Returns an array of 6 arrays (seconds, minutes, hours, days,
@@ -196,10 +208,53 @@ class Rufus::Scheduler
       ]
     end
 
+    # Returns a quickly computed approximation of the frequency for this
+    # cron line.
+    #
+    # #brute_frequency, on the other hand, will compute the frequency by
+    # examining a whole, that can take more than seconds for a seconds
+    # level cron...
+    #
+    def frequency
+
+      return brute_frequency unless @seconds && @seconds.length > 1
+
+      delta = 60
+      prev = @seconds[0]
+
+      @seconds[1..-1].each do |sec|
+        d = sec - prev
+        delta = d if d < delta
+      end
+
+      delta
+    end
+
     # Returns the shortest delta between two potential occurences of the
     # schedule described by this cronline.
     #
-    def frequency
+    # .
+    #
+    # For a simple cronline like "*/5 * * * *", obviously the frequency is
+    # five minutes. Why does this method look at a whole year of #next_time ?
+    #
+    # Consider "* * * * sun#2,sun#3", the computed frequency is 1 week
+    # (the shortest delta is the one between the second sunday and the third
+    # sunday). This method takes no chance and runs next_time for the span
+    # of a whole year and keeps the shortest.
+    #
+    # Of course, this method can get VERY slow if you call on it a second-
+    # based cronline...
+    #
+    # Since it's a rarely used method, I haven't taken the time to make it
+    # smarter/faster.
+    #
+    # One obvious improvement would be to cache the result once computed...
+    #
+    # See https://github.com/jmettraux/rufus-scheduler/issues/89
+    # for a discussion about this method.
+    #
+    def brute_frequency
 
       delta = 366 * DAY_S
 
@@ -380,6 +435,32 @@ class Rufus::Scheduler
 
       [ "#{WEEKDAYS[date.wday]}##{pos}", "#{WEEKDAYS[date.wday]}##{neg}" ]
     end
+
+    def local_time(time)
+
+      @timezone ? @timezone.utc_to_local(time.getutc) : time
+    end
+
+    def global_time(time, from_in_utc)
+
+      if @timezone
+        time =
+          begin
+            @timezone.local_to_utc(time)
+          rescue TZInfo::AmbiguousTime
+            @timezone.local_to_utc(time, time.isdst)
+          end
+        time = time.getlocal unless from_in_utc
+      end
+
+      time
+    end
+
+    def round_to_seconds(time)
+
+      # Ruby 1.8 doesn't have #round
+      time.respond_to?(:round) ? time.round : time - time.usec * 1e-6
+    end
   end
 end
 

data/lib/rufus/scheduler/job_array.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2013, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2014, 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
@@ -78,6 +78,13 @@ module Rufus
 
         @mutex.synchronize { @array.find { |j| j.job_id == job_id } }
       end
+
+      # Only used when shutting down, directly yields the underlying array.
+      #
+      def array
+
+        @array
+      end
     end
   end
 end

data/lib/rufus/scheduler/jobs.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2013, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2014, 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
@@ -45,6 +45,9 @@ module Rufus
       attr_reader :last_time
       attr_reader :unscheduled_at
       attr_reader :tags
+      attr_reader :count
+      attr_reader :last_work_time
+      attr_reader :mean_work_time
 
       # next trigger time
       #
@@ -82,8 +85,6 @@ module Rufus
         @scheduled_at = Time.now
         @unscheduled_at = nil
         @last_time = nil
-        #@mutexes = {}
-        #@pool_mutex = Mutex.new
 
         @locals = {}
         @local_mutex = Mutex.new
@@ -98,6 +99,10 @@ module Rufus
 
         @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
@@ -112,13 +117,18 @@ module Rufus
 
       def trigger(time)
 
-        set_next_time(false, time)
-
-        return if opts[:overlap] == false && running?
+        set_next_time(time)
 
-        r = callback(:pre, time)
+        return if (
+          opts[:overlap] == false &&
+          running?
+        )
+        return if (
+          callback(:confirm_lock, time) &&
+          callback(:on_pre_trigger, time)
+        ) == false
 
-        return if r == false
+        @count += 1
 
         if opts[:blocking]
           do_trigger(time)
@@ -183,17 +193,25 @@ module Rufus
         #
         # might be necessary at some point
 
-      protected
+      # 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(Time.now, do_rescue)
+      end
 
-      def callback(position, time)
+      protected
 
-        name = position == :pre ? :on_pre_trigger : :on_post_trigger
+      def callback(meth, time)
 
-        return unless @scheduler.respond_to?(name)
+        return true unless @scheduler.respond_to?(meth)
 
-        args = @scheduler.method(name).arity < 2 ? [ self ] : [ self, time ]
+        arity = @scheduler.method(meth).arity
+        args = [ self, time ][0, (arity < 0 ? 2 : arity)]
 
-        @scheduler.send(name, *args)
+        @scheduler.send(meth, *args)
       end
 
       def compute_timeout
@@ -210,6 +228,22 @@ module Rufus
         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]
+        @callable.call(*args)
+
+      rescue StandardError => se
+
+        raise 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)
 
         t = Time.now
@@ -221,19 +255,15 @@ module Rufus
 
         @last_time = t
 
-        args = [ self, time ][0, @callable.arity]
-        @callable.call(*args)
-
-      rescue KillSignal
-
-        # discard
-
-      rescue StandardError => se
-
-        @scheduler.on_error(self, se)
+        do_call(time, true)
 
       ensure
 
+        @last_work_time =
+          Time.now - Thread.current[:rufus_scheduler_time]
+        @mean_work_time =
+          ((@count - 1) * @mean_work_time + @last_work_time) / @count
+
         post_trigger(time)
 
         Thread.current[:rufus_scheduler_job] = nil
@@ -243,9 +273,9 @@ module Rufus
 
       def post_trigger(time)
 
-        set_next_time(true, time)
+        set_next_time(time, true)
 
-        callback(:post, time)
+        callback(:on_post_trigger, time)
       end
 
       def start_work_thread
@@ -290,15 +320,15 @@ module Rufus
 
       def do_trigger_in_thread(time)
 
-        #@pool_mutex.synchronize do
+        threads = @scheduler.work_threads
 
-        count = @scheduler.work_threads.size
-        #vacant = threads.select { |t| t[:rufus_scheduler_job] == nil }.size
+        cur = threads.size
+        vac = threads.select { |t| t[:rufus_scheduler_job] == nil }.size
         #min = @scheduler.min_work_threads
         max = @scheduler.max_work_threads
+        que = @scheduler.work_queue.size
 
-        start_work_thread if count < max
-        #end
+        start_work_thread if vac - que < 1 && cur < max
 
         @scheduler.work_queue << [ self, time ]
       end
@@ -308,6 +338,11 @@ module Rufus
 
       alias time next_time
 
+      def occurrences(time0, time1)
+
+        time >= time0 && time <= time1 ? [ time ] : []
+      end
+
       protected
 
       def determine_id
@@ -322,7 +357,7 @@ module Rufus
 
       # There is no next_time for one time jobs, hence the false.
       #
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         @next_time = is_post ? nil : false
       end
@@ -334,7 +369,8 @@ module Rufus
 
         super(scheduler, time, opts, block)
 
-        @next_time = Rufus::Scheduler.parse_at(time)
+        @next_time =
+          opts[:_t] || Rufus::Scheduler.parse_at(time, opts)
       end
     end
 
@@ -344,7 +380,9 @@ module Rufus
 
         super(scheduler, duration, opts, block)
 
-        @next_time = @scheduled_at + Rufus::Scheduler.parse_in(duration)
+        @next_time =
+          @scheduled_at +
+          opts[:_t] || Rufus::Scheduler.parse_in(duration, opts)
       end
     end
 
@@ -369,19 +407,24 @@ module Rufus
         ) unless @times == nil || @times.is_a?(Fixnum)
 
         self.first_at =
-          opts[:first] || opts[:first_at] || opts[:first_in] || 0
+          opts[:first] || opts[:first_time] ||
+          opts[:first_at] || opts[:first_in] ||
+          0
         self.last_at =
           opts[:last] || opts[:last_at] || opts[:last_in]
       end
 
       def first_at=(first)
 
+        n = Time.now
+        first = n + 0.001 if first == :now || first == :immediately
+
         @first_at = Rufus::Scheduler.parse_to_time(first)
 
         raise ArgumentError.new(
           "cannot set first[_at|_in] in the past: " +
           "#{first.inspect} -> #{@first_at.inspect}"
-        ) if first != 0 && @first_at < Time.now
+        ) if first != 0 && @first_at < n
       end
 
       def last_at=(last)
@@ -408,7 +451,7 @@ module Rufus
 
         super
 
-        @times = @times - 1 if @times
+        @times -= 1 if @times
       end
 
       def pause
@@ -434,6 +477,27 @@ module Rufus
           opts.hash.abs
         ].map(&:to_s).join('_')
       end
+
+      def occurrences(time0, time1)
+
+        a = []
+
+        nt = @next_time
+        ts = @times
+
+        loop do
+
+          break if nt > time1
+          break if ts && ts <= 0
+
+          a << nt if nt >= time0
+
+          nt = next_time_from(nt)
+          ts = ts - 1 if ts
+        end
+
+        a
+      end
     end
 
     #
@@ -464,12 +528,12 @@ module Rufus
           "of #{@frequency.inspect} (#{@original.inspect})"
         ) if @frequency <= 0
 
-        set_next_time(false, nil)
+        set_next_time(nil)
       end
 
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         return if is_post
 
@@ -482,6 +546,11 @@ module Rufus
             @first_at
           end
       end
+
+      def next_time_from(time)
+
+        time + @frequency
+      end
     end
 
     class IntervalJob < EvInJob
@@ -499,12 +568,12 @@ module Rufus
           "of #{@interval.inspect} (#{@original.inspect})"
         ) if @interval <= 0
 
-        set_next_time(false, nil)
+        set_next_time(nil)
       end
 
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         @next_time =
           if is_post
@@ -519,6 +588,11 @@ module Rufus
             false
           end
       end
+
+      def next_time_from(time)
+
+        time + @mean_work_time + @interval
+      end
     end
 
     class CronJob < RepeatJob
@@ -527,7 +601,7 @@ module Rufus
 
         super(scheduler, cronline, opts, block)
 
-        @cron_line = CronLine.new(cronline)
+        @cron_line = opts[:_t] || CronLine.new(cronline)
         @next_time = @cron_line.next_time
       end
 
@@ -536,12 +610,22 @@ module Rufus
         @cron_line.frequency
       end
 
+      def brute_frequency
+
+        @cron_line.brute_frequency
+      end
+
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         @next_time = @cron_line.next_time
       end
+
+      def next_time_from(time)
+
+        @cron_line.next_time(time)
+      end
     end
   end
 end

data/lib/rufus/scheduler/locks.rb

@@ -0,0 +1,95 @@
+#--
+# Copyright (c) 2006-2014, 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 'fileutils'
+
+
+class Rufus::Scheduler
+
+  #
+  # A lock that can always be acquired
+  #
+  class NullLock
+
+    # Locking is always successful.
+    #
+    def lock; true; end
+
+    def locked?; true; end
+    def unlock; true; end
+  end
+
+  #
+  # The standard flock mecha, with its own class thanks to @ecin
+  #
+  class FileLock
+
+    attr_reader :path
+
+    def initialize(path)
+
+      @path = path.to_s
+    end
+
+    # Locking is successful if this Ruby process can create and lock
+    # its lockfile (at the given path).
+    #
+    def lock
+
+      return true if locked?
+
+      @lockfile = nil
+
+      FileUtils.mkdir_p(::File.dirname(@path))
+
+      file = File.new(@path, File::RDWR | File::CREAT)
+      locked = file.flock(File::LOCK_NB | File::LOCK_EX)
+
+      return false unless locked
+
+      now = Time.now
+
+      file.print("pid: #{$$}, ")
+      file.print("scheduler.object_id: #{self.object_id}, ")
+      file.print("time: #{now}, ")
+      file.print("timestamp: #{now.to_f}")
+      file.flush
+
+      @lockfile = file
+
+      true
+    end
+
+    def unlock
+
+      !! (@lockfile && @lockfile.flock(File::LOCK_UN))
+    end
+
+    def locked?
+
+      !! (@lockfile && @lockfile.flock(File::LOCK_NB | File::LOCK_EX))
+    end
+  end
+end
+