rufus-scheduler 2.0.23 → 3.0.0

data/Rakefile

@@ -1,8 +1,5 @@
 
-$:.unshift('.') # 1.9.2
-
 require 'rubygems'
-require 'rubygems/user_interaction' if Gem::RubyGemsVersion == '1.5.0'
 
 require 'rake'
 require 'rake/clean'
@@ -42,7 +39,7 @@ desc %{
 task :build do
 
   sh "gem build #{GEMSPEC_FILE}"
-  sh "mkdir pkg" rescue nil
+  sh "mkdir -p pkg"
   sh "mv #{GEMSPEC.name}-#{GEMSPEC.version}.gem pkg/"
 end
 

data/TODO.txt

@@ -1,57 +1,147 @@
 
-[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
-
-[o] unify cron_jobs#trigger_matching_jobs(now) and jobs#job_to_trigger
-[o] pluggable job queues
-
-[ ] Joel's complaint about timeout jobs gone ballistic
-[x] move trigger_job out of the scheduler
+[o] merge schedule_queue and unschedule_queue (and merge [un]schedule steps)
+[x] OR stop using queue, since we've got the thread-safe JobArray
+[x] if possible, drop the mutex in JobArray
+    NO, that mutex is necessary for Scheduler#jobs (on JRuby an co)...
+[o] named mutexes
+[o] drop the schedule queue, rely on the mutex in JobArray
+[o] def jobs; (@jobs.to_a + running_jobs).uniq; end
+[o] replace @unscheduled by @unscheduled_at
+[o] make sure #jobs doesn't return unscheduled jobs
+[o] job tags and find_by_tag(t) (as in rs 2.x)
+[o] require tzinfo anyway (runtime dep)
+[o] document frequency
+[o] accept :frequency => '5s'
+[o] timeout (as in rufus-scheduler 2.x)
+[o] Rufus::Scheduler#running_jobs (as in rufus-scheduler 2.x)
+[o] Rufus::Scheduler#terminate_all_jobs
+[o] Rufus::Scheduler::Job#kill
+[x] Rufus::Scheduler#kill_all_jobs
+[o] Rufus::Scheduler#shutdown(:terminate or :kill (or nothing))
+[o] RepeatJob #pause / #resume (think about discard past)
+[o] Rufus::Scheduler.start_new (backward comp) (with deprec note?)
+[o] pass job to scheduled block? What does rs 2.x do?
+[o] :first[_in|_at] for RepeatJob
+[o] :last[_in|_at] for RepeatJob
+[o] :times for RepeatJob (how many recurrences)
+[o] fix issue #39 (first_at parses as UTC)
+[o] about issue #43, raise if cron/every job frequency < scheduler frequency
+[o] unlock spec/parse_spec.rb:30 "parse datimes with timezones"
+[o] some kind of Schedulable (Xyz#call(job, time))
+[o] add Jruby and Rubinius to Travis
+[o] make Job #first_at= / #last_at= automatically parse strings?
+[o] bring in Kratob's spec about mutex vs timeout and adapt 3.0 to it,
+    https://github.com/jmettraux/rufus-scheduler/pull/67
+[x] :unschedule_if => lambda { |job| ... }
+[o] OR look at how it was done in rs 2.0.x, some return value?
+    no, pass the job as arg to the block, then let the block do job.unschedule
+    so, document schedule.every('10d') { |j| j.unschedule if x?() }
+[x] remove the time in job.trigger(time)
+[o] add spec for job queued then unscheduled
+[o] add spec for Scheduler#shutdown and work threads
+[o] at some point, bring back rbx19 to Travis
+[o] move the parse/util part of scheduler.rb to util.rb
+[o] rescue KillSignal in job thread loop to kill just the job
+[o] add spec for raise if scheduling a job while scheduler is shutting down
+[o] schedule_in(2.days.from_now) {}
+    at and in could understand each others time parameter, ftw...
+    use the new #parse_to_time? no
+[o] do repeat jobs reschedule after timing out? yes
+[o] schedule_interval('20s')?
+[x] Scheduler#reschedule(job) (new copy of the job)
+[x] #free_all_work_threads is missing an implementation
+[x] rescue StandardError
+    :on_error => :crash[_scheduler]
+    :on_error => :ignore
+    :on_error => ...
+[o] on_error: what about TimeoutError in that scheme?
+    TimeoutError goes to $stderr, like a normal error
+[o] link to SO for support
+    - sublink to "how to report bugs effectively"
+[o] link to #ruote for support
+[x] lockblock? pass a block to teach the scheduler how to lock?
+    is not necessary, @scheduler = Scheduler.new if should_start?
+    the surrounding Ruby code checks
+[o] introduce job "vars", as in
+    http://stackoverflow.com/questions/18202848/how-to-have-a-variable-that-will-available-to-particular-scheduled-task-whenever
+    or job['key'] Job #[] and #[]=, as with Thread #[] #[]=
+    job-local variables #keys #key?
+[o] thread-safety for job-local variables?
+[x] discard past? discard_past => true or => "1d"
+    default would be discard_past => "1m" or scheduler freq * 2 ?
+    jobs would adjust their next_time until it fits the window...
+    ~~ discard past by default
+[o] expanded block/schedulable (it's "callable")
+    ```
+      scheduler.every '10m' do
+        def pre
+          return false if Backend.down?
+          # ...
+        end
+        def post
+          # ...
+        end
+        def trigger
+          puts "oh hai!"
+        end
+      end
+    ```
+    or something like that...
+    ...
+    OR accept a class (and instantiate it the first time)
+    ```
+      scheduler.every '10m', Class.new do
+        def call(job, time)
+          # ...
+        end
+      end
+    ```
+    the job contains the instance in its @callable
+[x] add spec case for corner case in Job#trigger (overlap vs reschedule) !!!
+[o] rethink job array vs job set for #scheduled?
+[x] introduce common parent class for EveryJob and IntervalJob
+[o] create spec/ at_job_spec.rb, repeat_job_spec.rb, cron_job_spec.rb, ...
+[x] ensure EveryJob do not schedule in the past (it's already like that)
+[o] CronLine#next_time should return a time with subseconds chopped off
+[o] drop min work threads setting?
+[o] thread pool something? Thread upper limit?
+[o] Rufus::Scheduler.singleton, Rufus::Scheduler.s
+[o] EveryJob#first_at= and IntervalJob#first_at= should alter @next_time
+[o] scheduler.schedule duration/time/cron ... for at/in/cron
+    (not every, nor interval)
+    scheduler.repeat time/cron ... for every/cron
+
+[o] :lockfile => x, timestamp, process_id, thread_id...
+    warning: have to clean up that file on exit... or does the scheduler
+    timestamps it?
+[ ] develop lockfile timestamp thinggy
+    ~ if the timestamp is too old (twice the default frequency?) then
+    lock [file] take over...
+    Is that really what we want all the time?
+
+[ ] idea: :mutex => x and :skip_on_mutex => true ?
+    would prevent blocking/waiting for the mutex to get available
+    :mutex => [ "mutex_name", true ]
+    :mutex => [ [ "mutex_name", true ], [ "other_mutex_name", false ] ]
+
+[ ] bring back EM (but only EM.defer ?) :defer => true (Job or Scheduler
+    or both option?)
+
+[ ] prepare a daemon, trust daemon-kit for that
+
+[ ] :if => lambda { |job, time| ... } why not?
+    :unless => lambda { ...
+    :block => lambda { ...
+    can help get the block themselves leaner
+    #
+    investigate guards for schedulables... def if_guard; ...; end
+
+[ ] scheduler.every '10', Class.new do
+      def call(job, time)
+        # might fail...
+      end
+      def on_error(err, job)
+        # catches...
+      end
+    end
 

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

@@ -22,10 +22,8 @@
 # Made in Japan.
 #++
 
-require 'tzinfo'
 
-
-module Rufus
+class Rufus::Scheduler
 
   #
   # A 'cron line' is a line in the sense of a crontab
@@ -33,9 +31,6 @@ module Rufus
   #
   class CronLine
 
-    DAY_S = 24 * 3600
-    WEEK_S = 7 * DAY_S
-
     # The string used for creating this cronline instance.
     #
     attr_reader :original
@@ -51,7 +46,9 @@ module Rufus
 
     def initialize(line)
 
-      super()
+      raise ArgumentError.new(
+        "not a string: #{line.inspect}"
+      ) unless line.is_a?(String)
 
       @original = line
 
@@ -123,12 +120,15 @@ module Rufus
     #
     # (Thanks to K Liu for the note and the examples)
     #
-    def next_time(now=Time.now)
+    def next_time(from=Time.now)
+
+      time = @timezone ? @timezone.utc_to_local(from.getutc) : from
 
-      time = @timezone ? @timezone.utc_to_local(now.getutc) : now
+      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 = time - time.usec * 1e-6 + 1
-        # small adjustment before starting
+      time = time + 1
+        # start at the next second
 
       loop do
 
@@ -150,7 +150,7 @@ module Rufus
 
       if @timezone
         time = @timezone.local_to_utc(time)
-        time = time.getlocal unless now.utc?
+        time = time.getlocal unless from.utc?
       end
 
       time
@@ -159,19 +159,19 @@ module Rufus
     # Returns the previous the cronline matched. It's like next_time, but
     # for the past.
     #
-    def previous_time(now=Time.now)
+    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)
 
-      start = current = now - 2 * 3600
+      start = current = from - 2 * 3600
       result = nil
 
       loop do
         nex = next_time(current)
-        return (result ? result : previous_time(start)) if nex > now
+        return (result ? result : previous_time(start)) if nex > from
         result = current = nex
       end
 
@@ -196,9 +196,38 @@ module Rufus
       ]
     end
 
-    private
+    # Returns the shortest delta between two potential occurences of the
+    # schedule described by this cronline.
+    #
+    def frequency
+
+      delta = 366 * DAY_S
+
+      t0 = previous_time(Time.local(2000, 1, 1))
+
+      loop do
+
+        break if delta <= 1
+        break if delta <= 60 && @seconds && @seconds.size == 1
+
+        t1 = next_time(t0)
+        d = t1 - t0
+        delta = d if d < delta
+
+        break if @months == nil && t1.month == 2
+        break if t1.year == 2001
+
+        t0 = t1
+      end
+
+      delta
+    end
+
+    protected
 
     WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
+    DAY_S = 24 * 3600
+    WEEK_S = 7 * DAY_S
 
     def parse_weekdays(item)
 
@@ -281,7 +310,7 @@ module Rufus
 
       raise ArgumentError.new(
         "#{item.inspect} is not in range #{min}..#{max}"
-      ) if sta < min or edn > max
+      ) if sta < min || edn > max
 
       r = []
       val = sta

data/lib/rufus/{sc/version.rb → scheduler/job_array.rb}

@@ -22,11 +22,63 @@
 # Made in Japan.
 #++
 
-
 module Rufus
-module Scheduler
 
-  VERSION = '2.0.23'
-end
+  class Scheduler
+
+    #
+    # 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.synchronize { @array << job unless @array.index(job) }
+
+        self
+      end
+
+      def size
+
+        @array.size
+      end
+
+      def each(now, &block)
+
+        to_a.sort_by { |j| j.next_time || (now + 1) }.each do |job|
+
+          break unless job.next_time
+          break if job.next_time > now
+
+          block.call(job)
+        end
+      end
+
+      def delete_unscheduled
+
+        @mutex.synchronize {
+
+          @array.delete_if { |j| j.next_time.nil? || j.unscheduled_at }
+        }
+      end
+
+      def to_a
+
+        @mutex.synchronize { @array.dup }
+      end
+
+      def [](job_id)
+
+        @mutex.synchronize { @array.find { |j| j.job_id == job_id } }
+      end
+    end
+  end
 end