rufus-scheduler 1.0.5 → 1.0.6

data/test/cron_test.rb

@@ -17,118 +17,118 @@ require 'openwfe/util/scheduler'
 #
 class CronTest < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    def test_0
+  def test_0
 
-        $var = 0
+    $var = 0
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.start
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.start
 
-        sid = scheduler.schedule(
-            '* * * * *',
-            :schedulable => CounterSchedulable.new)
+    sid = scheduler.schedule(
+      '* * * * *',
+      :schedulable => CounterSchedulable.new)
 
-        assert sid, "scheduler did not return a job id"
+    assert sid, "scheduler did not return a job id"
 
-        sleep 120
-        scheduler.stop
+    sleep 120
+    scheduler.stop
 
-        #puts ">#{$var}<"
+    #puts ">#{$var}<"
 
-        assert_equal 2, $var
-    end
+    assert_equal 2, $var
+  end
+
+  def test_1
+
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.start
 
-    def test_1
-
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.start
-
-        sec = nil
-        has_gone_wrong = false
-        counter = 0
-
-        scheduler.schedule "* * * * * *" do
-            t = Time.new
-            if (t.sec == sec)
-                has_gone_wrong = true
-            #    print "x"
-            #else
-            #    print "."
-            end
-            #STDOUT.flush
-            sec = t.sec
-            counter = counter + 1
-        end
-
-        sleep 10
-        scheduler.stop
-
-        #assert_equal 10, counter
-        assert [ 9, 10 ].include?(counter), "not 9 or 10 but #{counter}"
-        assert (not has_gone_wrong)
+    sec = nil
+    has_gone_wrong = false
+    counter = 0
+
+    scheduler.schedule "* * * * * *" do
+      t = Time.new
+      if (t.sec == sec)
+        has_gone_wrong = true
+      #  print "x"
+      #else
+      #  print "."
+      end
+      #STDOUT.flush
+      sec = t.sec
+      counter = counter + 1
     end
 
-    def test_2
+    sleep 10
+    scheduler.stop
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.start
+    #assert_equal 10, counter
+    assert [ 9, 10 ].include?(counter), "not 9 or 10 but #{counter}"
+    assert (not has_gone_wrong)
+  end
 
-        counter = 0
+  def test_2
 
-        scheduler.schedule "7 * * * * *" do
-            counter += 1
-        end
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.start
 
-        sleep 61
-        scheduler.stop
+    counter = 0
 
-        assert_equal 1, counter
-            # baby just one ... time
+    scheduler.schedule "7 * * * * *" do
+      counter += 1
     end
 
-    #
-    # testing cron unschedule
-    #
-    def test_3
+    sleep 61
+    scheduler.stop
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.start
+    assert_equal 1, counter
+      # baby just one ... time
+  end
 
-        counter = 0
+  #
+  # testing cron unschedule
+  #
+  def test_3
 
-        job_id = scheduler.schedule "* * * * *" do
-            counter += 1
-        end
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.start
 
-        sleep 0.300
+    counter = 0
 
-        #puts "job_id : #{job_id}"
+    job_id = scheduler.schedule "* * * * *" do
+      counter += 1
+    end
 
-        assert_equal 1, scheduler.cron_job_count
+    sleep 0.300
 
-        scheduler.unschedule job_id
+    #puts "job_id : #{job_id}"
 
-        sleep 0.300
+    assert_equal 1, scheduler.cron_job_count
 
-        assert_equal 0, scheduler.cron_job_count
+    scheduler.unschedule job_id
 
-        scheduler.stop
-    end
+    sleep 0.300
+
+    assert_equal 0, scheduler.cron_job_count
 
-    protected
+    scheduler.stop
+  end
 
-        class CounterSchedulable
-            include OpenWFE::Schedulable
+  protected
 
-            def trigger (params)
-                $var = $var + 1
-            end
-        end
+    class CounterSchedulable
+      include OpenWFE::Schedulable
+
+      def trigger (params)
+        $var = $var + 1
+      end
+    end
 
 end

data/test/cronline_test.rb

@@ -18,38 +18,44 @@ require 'rufus/scheduler'
 #
 class CronLineTest < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    def test_0
+  def test_0
 
-        dotest "* * * * *", [ [0], nil, nil, nil, nil, nil ]
-        dotest "10-12 * * * *", [ [0], [10, 11, 12], nil, nil, nil, nil ]
-        dotest "* * * * sun,mon", [ [0], nil, nil, nil, nil, [7, 1] ]
-        dotest "* * * * mon-wed", [ [0], nil, nil, nil, nil, [1, 2, 3] ]
+    dotest "* * * * *", [ [0], nil, nil, nil, nil, nil ]
+    dotest "10-12 * * * *", [ [0], [10, 11, 12], nil, nil, nil, nil ]
+    dotest "* * * * sun,mon", [ [0], nil, nil, nil, nil, [0, 1] ]
+    dotest "* * * * mon-wed", [ [0], nil, nil, nil, nil, [1, 2, 3] ]
+    dotest "* * * * 7", [ [0], nil, nil, nil, nil, [0] ]
+    dotest "* * * * 0", [ [0], nil, nil, nil, nil, [0] ]
+    dotest "* * * * 0,1", [ [0], nil, nil, nil, nil, [0,1] ]
+    dotest "* * * * 7,1", [ [0], nil, nil, nil, nil, [0,1] ]
+    dotest "* * * * 7,0", [ [0], nil, nil, nil, nil, [0] ]
+    dotest "* * * * sun,2-4", [ [0], nil, nil, nil, nil, [0, 2, 3, 4] ]
 
-        #dotest "* * * * sun,mon-tue", [ [0], nil, nil, nil, nil, [7, 1, 2] ]
-        #dotest "* * * * 7-1", [ [0], nil, nil, nil, nil, [7, 1, 2] ]
-    end
+    dotest "* * * * sun,mon-tue", [ [0], nil, nil, nil, nil, [0, 1, 2] ]
+    #dotest "* * * * 7-1", [ [0], nil, nil, nil, nil, [0, 1, 2] ]
+  end
 
-    def test_1
+  def test_1
 
-        dotest "* * * * * *", [ nil, nil, nil, nil, nil, nil ]
-        dotest "1 * * * * *", [ [1], nil, nil, nil, nil, nil ]
-        dotest "7 10-12 * * * *", [ [7], [10, 11, 12], nil, nil, nil, nil ]
-        dotest "1-5 * * * * *", [ [1,2,3,4,5], nil, nil, nil, nil, nil ]
-    end
+    dotest "* * * * * *", [ nil, nil, nil, nil, nil, nil ]
+    dotest "1 * * * * *", [ [1], nil, nil, nil, nil, nil ]
+    dotest "7 10-12 * * * *", [ [7], [10, 11, 12], nil, nil, nil, nil ]
+    dotest "1-5 * * * * *", [ [1,2,3,4,5], nil, nil, nil, nil, nil ]
+  end
 
-    protected
+  protected
 
-        def dotest (line, array)
+    def dotest (line, array)
 
-            cl = Rufus::CronLine.new(line)
+      cl = Rufus::CronLine.new(line)
 
-            assert_equal array, cl.to_array
-        end
+      assert_equal array, cl.to_array
+    end
 
 end

data/test/dev.rb

@@ -0,0 +1,28 @@
+
+#require 'rubygems'
+require 'rufus/scheduler'
+
+s = Rufus::Scheduler.new
+s.precision = 1.250
+#s.precision = 0.250
+#s.precision = 30
+s.start
+
+def compute_dev (s, t0, t1)
+
+  return 0.0 unless t0
+  s.precision - (t1 - t0)
+end
+
+tprev = nil
+tcurr = nil
+
+#s.schedule "* * * * * *" do
+s.schedule "* * * * *" do
+  tprev = tcurr
+  tcurr = Time.new
+  puts "#{tcurr.to_s} #{tcurr.to_f}  (#{compute_dev(s, tprev, tcurr)})"
+end
+
+s.join 
+

data/test/scheduler_0_test.rb

@@ -15,347 +15,347 @@ require 'openwfe/util/scheduler'
 # testing otime and the scheduler
 #
 
-class SchedulerTest < Test::Unit::TestCase
+class Scheduler0Test < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
+
+  def test_scheduler_0
+
+    #Thread.abort_on_exception = true
+
+    $var = nil
+
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-    def test_scheduler_0
+    sid = scheduler.schedule_in('2s', :schedulable => TestSchedulable.new)
 
-        #Thread.abort_on_exception = true
+    assert \
+      sid,
+      "scheduler_0 did not return a job id"
 
-        $var = nil
+    assert \
+      (not $var),
+      "scheduler_0 is blocking but should not"
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+    sleep 2.5
 
-        sid = scheduler.schedule_in('2s', :schedulable => TestSchedulable.new)
+    assert_equal 0, scheduler.cron_job_count
+    assert_equal 0, scheduler.every_job_count
+    assert_equal 0, scheduler.at_job_count
+    assert_equal 0, scheduler.pending_job_count
 
-        assert \
-            sid,
-            "scheduler_0 did not return a job id"
+    scheduler.sstop
 
-        assert \
-            (not $var),
-            "scheduler_0 is blocking but should not"
+    #puts ">#{$var}<"
 
-        sleep 2.5
+    assert_equal "ok", $var
+  end
 
-        assert_equal 0, scheduler.cron_job_count
-        assert_equal 0, scheduler.every_job_count
-        assert_equal 0, scheduler.at_job_count
-        assert_equal 0, scheduler.pending_job_count
+  def test_scheduler_1
 
-        scheduler.sstop
+    $var = nil
 
-        #puts ">#{$var}<"
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-        assert_equal "ok", $var
+    sid = scheduler.schedule_in('1s') do
+      $var = "ok..1"
     end
 
-    def test_scheduler_1
+    assert \
+      sid,
+      "scheduler_1 did not return a job id"
 
-        $var = nil
+    assert \
+      (not $var),
+      "scheduler_1 is blocking but should not"
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+    sleep 2
+    scheduler.sstop
 
-        sid = scheduler.schedule_in('1s') do
-            $var = "ok..1"
-        end
+    #puts ">#{$var}<"
 
-        assert \
-            sid,
-            "scheduler_1 did not return a job id"
+    assert "ok..1", $var
+  end
 
-        assert \
-            (not $var),
-            "scheduler_1 is blocking but should not"
+  #
+  # test idea by ara.t.howard on the ruby-talk ml
+  #
+  def test_scheduler_2
 
-        sleep 2
-        scheduler.sstop
+    text = ""
 
-        #puts ">#{$var}<"
+    scheduler = OpenWFE::Scheduler.new()
+    scheduler.sstart
 
-        assert "ok..1", $var
+    scheduler.schedule_in("1s") do
+      text << "one"
+      sleep(2)
+    end
+    scheduler.schedule_in("1s") do
+      text << "two"
     end
 
-    #
-    # test idea by ara.t.howard on the ruby-talk ml
-    #
-    def test_scheduler_2
-
-        text = ""
+    sleep(2)
 
-        scheduler = OpenWFE::Scheduler.new()
-        scheduler.sstart
+    scheduler.sstop
 
-        scheduler.schedule_in("1s") do
-            text << "one"
-            sleep(2)
-        end
-        scheduler.schedule_in("1s") do
-            text << "two"
-        end
+    #puts text
 
-        sleep(2)
+    assert_equal text, "onetwo"
+  end
 
-        scheduler.sstop
+  #
+  # Testing schedule_every()
+  #
+  def test_scheduler_4
 
-        #puts text
+    Thread.abort_on_exception = true
 
-        assert_equal text, "onetwo"
-    end
+    scheduler = OpenWFE::Scheduler.new()
+    scheduler.sstart
 
     #
-    # Testing schedule_every()
-    #
-    def test_scheduler_4
+    # phase 0
 
-        Thread.abort_on_exception = true
+    count = 0
 
-        scheduler = OpenWFE::Scheduler.new()
-        scheduler.sstart
+    job_id = scheduler.schedule_every("1s") do
+      count += 1
+    end
 
-        #
-        # phase 0
+    #puts "0 job_id : " + job_id.to_s
 
-        count = 0
+    sleep 3.5
 
-        job_id = scheduler.schedule_every("1s") do
-            count += 1
-        end
+    assert_equal 3, count
 
-        #puts "0 job_id : " + job_id.to_s
+    job = scheduler.get_job job_id
 
-        sleep 3.5
+    assert_equal "1s", job.schedule_info
 
-        assert_equal 3, count
+    assert_job_count scheduler, 0, 0, 1
 
-        job = scheduler.get_job job_id
+    #
+    # phase 1
 
-        assert_equal "1s", job.schedule_info
+    es = EverySchedulable.new
 
-        assert_job_count scheduler, 0, 0, 1
+    job_id = scheduler.schedule_every "500", es
 
-        #
-        # phase 1
+    #puts "1 job_id : " + job_id.to_s
+    
+    #sleep(3.4) # was a bit soonish for JRuby...
+    sleep 3.5
 
-        es = EverySchedulable.new
+    #assert_job_count scheduler, 0, 0, 2
+    assert_equal 6, es.count
 
-        job_id = scheduler.schedule_every "500", es
+    scheduler.unschedule job_id
 
-        #puts "1 job_id : " + job_id.to_s
-        
-        #sleep(3.4) # was a bit soonish for JRuby...
-        sleep 3.5
+    sleep 1
 
-        #assert_job_count scheduler, 0, 0, 2
-        assert_equal 6, es.count
+    assert_equal 6, es.count
 
-        scheduler.unschedule job_id
+    # done
 
-        sleep 1
+    scheduler.sstop
+  end
 
-        assert_equal 6, es.count
+  #
+  # testing to see if the scheduler immediately executes schedule_in(t)
+  # requests where t < scheduler.frequency.
+  # (100ms < 250ms)
+  #
+  def test_scheduler_5
 
-        # done
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.sstart
 
-        scheduler.sstop
+    touched = false
+
+    scheduler.schedule_in "100" do
+      touched = true
     end
 
-    #
-    # testing to see if the scheduler immediately executes schedule_in(t)
-    # requests where t < scheduler.frequency.
-    # (100ms < 250ms)
-    #
-    def test_scheduler_5
+    assert touched
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.sstart
+    scheduler.sstop
+  end
 
-        touched = false
+  #
+  # Testing to see if a second job with the same id discards the first one.
+  #
+  def test_scheduler_6
 
-        scheduler.schedule_in "100" do
-            touched = true
-        end
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.start
 
-        assert touched
+    #class << scheduler
+    #  attr_reader :pending_jobs
+    #end
 
-        scheduler.sstop
-    end
+    value = nil
 
-    #
-    # Testing to see if a second job with the same id discards the first one.
-    #
-    def test_scheduler_6
+    scheduler.schedule_in "3s", :job_id => "job" do
+      value = 0
+    end
+    scheduler.schedule_in "2s", :job_id => "job" do
+      value = 1
+    end
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.start
+    sleep 0.5
 
-        #class << scheduler
-        #    attr_reader :pending_jobs
-        #end
+    #puts scheduler.pending_jobs.collect { |j| j.job_id }.inspect
+    assert_job_count scheduler, 0, 1, 0
 
-        value = nil
+    assert_nil value
 
-        scheduler.schedule_in "3s", :job_id => "job" do
-            value = 0
-        end
-        scheduler.schedule_in "2s", :job_id => "job" do
-            value = 1
-        end
+    sleep 2.0
 
-        sleep 0.5
+    #puts scheduler.pending_jobs.collect { |j| j.job_id }.inspect
+    assert_job_count scheduler, 0, 0, 0
 
-        #puts scheduler.pending_jobs.collect { |j| j.job_id }.inspect
-        assert_job_count scheduler, 0, 1, 0
+    assert_equal 1, value
 
-        assert_nil value
+    sleep 4
 
-        sleep 2.0
+    assert_equal 1, value
 
-        #puts scheduler.pending_jobs.collect { |j| j.job_id }.inspect
-        assert_job_count scheduler, 0, 0, 0
+    scheduler.stop
+  end
 
-        assert_equal 1, value
+  #
+  # Testing custom precision.
+  #
+  def test_scheduler_7
 
-        sleep 4
+    scheduler = Rufus::Scheduler.new(:scheduler_precision => 0.100)
 
-        assert_equal 1, value
+    assert_equal 0.100, scheduler.precision
+  end
 
-        scheduler.stop
-    end
+  #
+  # Making sure that a job scheduled in the past is executed immediately
+  # and not scheduled.
+  #
+  # This test also makes sure that schedule_at() understands the
+  # time.to_s format.
+  #
+  def test_8
 
-    #
-    # Testing custom precision.
-    #
-    def test_scheduler_7
+    scheduler = Rufus::Scheduler.new
+    scheduler.start
 
-        scheduler = Rufus::Scheduler.new(:scheduler_precision => 0.100)
+    var = false
 
-        assert_equal 0.100, scheduler.precision
+    job_id = scheduler.schedule_at Time.now.to_s do
+      var = true
     end
 
-    #
-    # Making sure that a job scheduled in the past is executed immediately
-    # and not scheduled.
-    #
-    # This test also makes sure that schedule_at() understands the
-    # time.to_s format.
-    #
-    def test_8
+    assert_equal var, true
+    assert_nil job_id
+  end
 
-        scheduler = Rufus::Scheduler.new
-        scheduler.start
+  #
+  # Scheduling in the past, with :discard_past set to true.
+  #
+  def test_8b
 
-        var = false
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.start
 
-        job_id = scheduler.schedule_at Time.now.to_s do
-            var = true
-        end
+    var = nil
 
-        assert_equal var, true
-        assert_nil job_id
+    job_id = scheduler.schedule_at(Time.now.to_s, :discard_past => true) do
+      var = "something"
     end
 
-    #
-    # Scheduling in the past, with :discard_past set to true.
-    #
-    def test_8b
+    assert_nil var
+    assert_nil job_id
 
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.start
+    scheduler.stop
+  end
 
-        var = nil
+  #
+  # Testing restarting the scheduler.
+  #
+  def test_9
 
-        job_id = scheduler.schedule_at(Time.now.to_s, :discard_past => true) do
-            var = "something"
-        end
+    scheduler = OpenWFE::Scheduler.new
+    scheduler.start
 
-        assert_nil var
-        assert_nil job_id
+    value = nil
 
-        scheduler.stop
+    scheduler.schedule_in "2s" do
+      value = 0
     end
 
-    #
-    # Testing restarting the scheduler.
-    #
-    def test_9
-
-        scheduler = OpenWFE::Scheduler.new
-        scheduler.start
+    assert_nil value
 
-        value = nil
+    scheduler.stop
 
-        scheduler.schedule_in "2s" do
-            value = 0
-        end
+    sleep 0.5
 
-        assert_nil value
+    scheduler.start
 
-        scheduler.stop
+    assert_nil value
 
-        sleep 0.5
+    sleep 2
 
-        scheduler.start
+    assert_equal value, 0
 
-        assert_nil value
+    scheduler.stop
+  end
 
-        sleep 2
+  def test_10
 
-        assert_equal value, 0
-
-        scheduler.stop
+    e = nil
+    begin
+      OpenWFE::Scheduler.new.precision = 10
+    rescue Exception => e
     end
 
-    def test_10
-
-        e = nil
-        begin
-            OpenWFE::Scheduler.new.precision = 10
-        rescue Exception => e
-        end
+    assert_not_nil e, "exception not caught"
+  end
 
-        assert_not_nil e, "exception not caught"
-    end
-
-    protected
+  protected
 
-        class TestSchedulable
-            include OpenWFE::Schedulable
+    class TestSchedulable
+      include OpenWFE::Schedulable
 
-            def trigger (params)
-                $var = "ok"
-            end
-        end
+      def trigger (params)
+        $var = "ok"
+      end
+    end
 
-        class EverySchedulable
-            include OpenWFE::Schedulable
+    class EverySchedulable
+      include OpenWFE::Schedulable
 
-            attr_accessor :job_id, :count
+      attr_accessor :job_id, :count
 
-            def initialize
-                @job_id = -1
-                @count = 0
-            end
+      def initialize
+        @job_id = -1
+        @count = 0
+      end
 
-            def trigger (params)
-                #puts "toto"
-                @count += 1
-            end
-        end
+      def trigger (params)
+        #puts "toto"
+        @count += 1
+      end
+    end
 
-        def assert_job_count (scheduler, cron, at, every)
+    def assert_job_count (scheduler, cron, at, every)
 
-            assert_equal cron, scheduler.cron_job_count
-            assert_equal at, scheduler.at_job_count
-            assert_equal every, scheduler.every_job_count
-            assert_equal at + every, scheduler.pending_job_count
-        end
+      assert_equal cron, scheduler.cron_job_count
+      assert_equal at, scheduler.at_job_count
+      assert_equal every, scheduler.every_job_count
+      assert_equal at + every, scheduler.pending_job_count
+    end
 
 end