rufus-scheduler 2.0.3 → 2.0.4

data/spec/stress_schedule_unschedule_spec.rb

@@ -0,0 +1,155 @@
+
+$LOAD_PATH << 'lib'
+require 'rufus/sc/scheduler'
+
+require 'rubygems'
+require 'eventmachine'
+
+#require 'spec/autorun'
+require File.dirname(__FILE__) + '/spec_base'
+
+JOB_COUNT = 500 # 1000
+JOB_IDS = (1..JOB_COUNT).to_a
+NUM_RESCHEDULES = 5 # 10
+TRIGGER_DELAY = 4 # 15
+
+describe SCHEDULER_CLASS do
+
+# helper methods
+
+#
+# Wait for a variable to become a certain value.
+# This method returns a block which loops waiting for the passed in
+# block paramter to have value 'target'.
+#
+def eventually(timeout = TRIGGER_DELAY * 2, precision = 1)
+  lambda { |target|
+    value = nil
+    (timeout/precision).to_i.times do
+      value = yield # read variable once
+      # puts "got #{value}, expected #{target}"
+      break if target == value
+      sleep precision
+    end
+    target == value
+  }
+end
+
+def benchmark
+  now = Time.now
+  yield
+  benchmark = Time.now - now
+  print " (scheduling took #{benchmark}s)"
+  if benchmark > TRIGGER_DELAY
+    puts "\nTEST RESULT INVALID/UNRELIABLE"
+    puts "Scheduling took longer than TRIGGER_DELAY (#{TRIGGER_DELAY}s)."
+    puts "Increase TRIGGER_DELAY to a value larger than largest scheduling time."
+  end
+end
+
+def schedule_unschedule_same_ids_spec (mode)
+  scheduler = SCHEDULER_CLASS.start_new
+  benchmark { schedule_unschedule(scheduler, mode, NUM_RESCHEDULES) }
+  JOB_COUNT.should.satisfy &eventually { scheduler.all_jobs.size }
+  JOB_IDS.sort.should.equal(scheduler.find_jobs.map{ |job| job.job_id }.sort)
+  JOB_COUNT.should.satisfy &eventually { @trigger_queue.size }
+  @trigger_queue.size.should.equal(JOB_COUNT)
+  scheduler.stop
+end
+
+def schedule_unschedule_unique_ids_spec (mode)
+  scheduler = SCHEDULER_CLASS.start_new
+  job_ids = []
+  benchmark { job_ids = schedule_unschedule(scheduler, mode, NUM_RESCHEDULES, true) }
+  JOB_COUNT.should.satisfy &eventually { scheduler.all_jobs.size }
+  job_ids.sort.should.equal(scheduler.find_jobs.map{ |job| job.job_id }.sort)
+  JOB_COUNT.should.satisfy &eventually { @trigger_queue.size }
+  @trigger_queue.size.should.equal(JOB_COUNT)
+  scheduler.stop
+end
+
+def scheduler_counts(scheduler)
+  "all:%d at:%d cron:%d every:%d pending:%d" % [
+    scheduler.all_jobs.size,
+    scheduler.at_job_count,
+    scheduler.cron_job_count,
+    scheduler.every_job_count,
+    scheduler.pending_job_count]
+end
+
+def schedule_unschedule(scheduler, mode, num_reschedules, generate_ids = false)
+  job_ids = schedule_jobs(scheduler, mode, generate_ids)
+  1.upto(num_reschedules) do
+    unschedule_jobs(scheduler, job_ids)
+    job_ids = schedule_jobs(scheduler, mode, generate_ids)
+  end
+  job_ids
+end
+
+def schedule_jobs(scheduler, mode, generate_ids = false)
+  job_ids = []
+  JOB_IDS.each do |job_id|
+    case mode
+    when :cron
+      job_ids << scheduler.cron("%d * * * * *" % @cron_trigger,
+                                { :job_id => (generate_ids ? nil : job_id) },
+                                &@trigger_proc).job_id
+    when :at
+      job_ids << scheduler.at(@at_trigger,
+                              { :job_id => (generate_ids ? nil : job_id) },
+                              &@trigger_proc).job_id
+    when :every
+      job_ids << scheduler.every(@every_trigger,
+                                 { :job_id => (generate_ids ? nil : job_id) },
+                                 &@trigger_proc).job_id
+    else
+      raise ArgumentError
+    end
+  end
+  job_ids
+end
+
+def unschedule_jobs(scheduler, job_ids)
+  job_ids.each { |job_id| scheduler.unschedule(job_id) }
+end
+
+# the actual tests
+
+before do #(:each) do
+  @trigger_queue = Queue.new
+  @cron_trigger = ((Time.now.to_i%60) + TRIGGER_DELAY) % 60 # 30 seconds from now
+  @at_trigger = Time.now + TRIGGER_DELAY
+  @every_trigger = "#{TRIGGER_DELAY}s"
+  @trigger_proc = lambda { |job| @trigger_queue << job.job_id }
+end
+
+after do #(:each) do
+  @trigger_queue = nil
+end
+
+it "should sustain frequent schedule/unschedule 'cron' jobs with same ids" do
+  schedule_unschedule_same_ids_spec(:cron)
+end
+
+it "should sustain frequent schedule/unschedule 'at' jobs with same ids" do
+  schedule_unschedule_same_ids_spec(:at)
+end
+
+it "should sustain frequent schedule/unschedule 'every' jobs same ids" do
+  schedule_unschedule_same_ids_spec(:every)
+end
+
+it "should sustain frequent schedule/unschedule 'cron' jobs with unique ids" do
+  schedule_unschedule_unique_ids_spec(:cron)
+end
+
+it "should sustain frequent schedule/unschedule 'at' jobs with unique ids" do
+  schedule_unschedule_unique_ids_spec(:at)
+end
+
+it "should sustain frequent schedule/unschedule 'every' jobs unique ids" do
+  schedule_unschedule_unique_ids_spec(:every)
+end
+
+end
+

data/spec/timeout_spec.rb

@@ -0,0 +1,103 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Sun May  3 15:44:28 JST 2009
+#
+
+require File.dirname(__FILE__) + '/spec_base'
+
+
+describe "#{SCHEDULER_CLASS} timeouts" do
+
+  before do
+    @s = start_scheduler
+  end
+  after do
+    stop_scheduler(@s)
+  end
+
+  it 'should should refuse to schedule a job with :timeout and :blocking' do
+
+    lambda {
+      @s.in '1s', :timeout => '3s', :blocking => true do
+      end
+    }.should.raise(ArgumentError)
+  end
+
+  it 'should schedule a dedicated job for the timeout' do
+
+    @s.in '1s', :timeout => '3s' do
+      sleep 5
+    end
+
+    @s.jobs.size.should.equal(1)
+
+    # the timeout job is left
+
+    sleep 2
+    @s.jobs.size.should.equal(1)
+    @s.find_by_tag('timeout').size.should.equal(1)
+  end
+
+  it 'should time out' do
+
+    var = nil
+    timedout = false
+
+    @s.in '1s', :timeout => '1s' do
+      begin
+        sleep 2
+        var = true
+      rescue Rufus::Scheduler::TimeOutError => e
+        timedout = true
+      end
+    end
+
+    sleep 4
+
+    var.should.be.nil
+    @s.jobs.size.should.equal(0)
+    timedout.should.be.true
+  end
+
+  it 'should die silently if job finished before timeout' do
+
+    var = nil
+    timedout = false
+
+    @s.in '1s', :timeout => '1s' do
+      begin
+        var = true
+      rescue Rufus::Scheduler::TimeOutError => e
+        timedout = true
+      end
+    end
+
+    sleep 3
+
+    var.should.be.true
+    @s.jobs.size.should.equal(0)
+    timedout.should.be.false
+  end
+
+  it 'should not timeout other jobs (in case of every)' do
+
+    timeouts = []
+
+    @s.every '1s', :timeout => '1s500' do
+      start = Time.now
+      begin
+        sleep 2.0
+      rescue Rufus::Scheduler::TimeOutError => e
+        timeouts << (Time.now - start)
+      end
+    end
+
+    sleep 5
+
+    timeouts.size.should.equal(3)
+    timeouts.each { |to| (to * 10).to_i.should.equal(16) }
+  end
+end
+

data/test/kjw.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+#
+# A test by http://twitter.com/kjw
+#
+
+require 'test/unit'
+$LOAD_PATH << 'lib'
+require 'rufus/sc/scheduler'
+
+require 'rubygems'
+require 'eventmachine'
+
+class CronTest < Test::Unit::TestCase
+
+#
+# Stress test program for rufus-scheduler
+#
+
+SECONDS_FROM_NOW = 30
+MODE = :cron
+JOB_COUNT = 1000
+JOB_IDS = (1..JOB_COUNT).to_a
+NUM_RESCHEDULES = 20
+
+def setup
+  @trigger_queue = Queue.new
+end
+
+def test_stress_schedule_unschedule_plain_cron
+  stress_schedule_unschedule(:cron, Rufus::Scheduler::PlainScheduler.start_new)
+end
+
+def test_stress_schedule_unschedule_plain_at
+  stress_schedule_unschedule(:at, Rufus::Scheduler::PlainScheduler.start_new)
+end
+
+def test_stress_schedule_unschedule_plain_every
+  stress_schedule_unschedule(:every, Rufus::Scheduler::PlainScheduler.start_new)
+end
+
+def test_stress_schedule_unschedule_em_cron
+  stress_schedule_unschedule(:cron, Rufus::Scheduler::EmScheduler.start_new)
+end
+
+def test_stress_schedule_unschedule_em_at
+  stress_schedule_unschedule(:at, Rufus::Scheduler::EmScheduler.start_new)
+end
+
+def test_stress_schedule_unschedule_em_every
+  stress_schedule_unschedule(:every, Rufus::Scheduler::EmScheduler.start_new)
+end
+
+protected
+
+def stress_schedule_unschedule(mode, scheduler)
+
+  # Schedule all jobs, then unschedule and (re)schedule a number of times
+  schedule_unschedule(scheduler, mode, NUM_RESCHEDULES)
+
+  # give scheduler thread 10 seconds to process the schedule and unschedule requests
+  # but don't wait for the jobs to trigger (which is in less than 30 seconds)
+  sleep 10
+  # print_scheduler_counts(scheduler, 10)
+
+  # by now the scheduler should have processed everything, check
+  assert(JOB_IDS.sort == scheduler.find_jobs.map{ |job| job.job_id }.sort)
+  sleep SECONDS_FROM_NOW # wait for jobs to trigger
+  assert(JOB_COUNT == @trigger_queue.size)
+end
+
+def schedule_unschedule(scheduler, mode, num_reschedules)
+  schedule_jobs(scheduler, mode)
+  1.upto(num_reschedules) do
+    sleep 0.01 # cause schedule's to happen before unscheduling
+    unschedule_jobs(scheduler)
+    schedule_jobs(scheduler, mode)
+  end
+end
+
+def print_scheduler_counts(scheduler, seconds)
+  1.upto(seconds) do
+    puts "all:%d at:%d cron:%d every:%d pending:%d" % [
+      scheduler.all_jobs.size,
+      scheduler.at_job_count,
+      scheduler.cron_job_count,
+      scheduler.every_job_count,
+      scheduler.pending_job_count]
+    sleep 1
+  end
+end
+
+def schedule_jobs(scheduler, mode)
+  trigger_proc = lambda { |params| @trigger_queue << params[:job_id] }
+  JOB_IDS.each do |job_id|
+    case mode
+    when :at
+      scheduler.at(Time.now + SECONDS_FROM_NOW, {:job_id => job_id}, &trigger_proc)
+    when :every
+      scheduler.every("#{SECONDS_FROM_NOW}s", {:job_id => job_id}, &trigger_proc)
+    when :cron
+      scheduler.cron("%d * * * * *" % ((Time.now.to_i%60) + SECONDS_FROM_NOW) % 60,
+                     {:job_id => job_id}, &trigger_proc)
+    end
+  end
+end
+
+def unschedule_jobs(scheduler)
+  JOB_IDS.each { |job_id| scheduler.unschedule(job_id) }
+end
+
+end
+

data/test/t.rb

@@ -0,0 +1,20 @@
+
+$:.unshift('lib')
+
+require 'rubygems'
+require 'rufus/scheduler/em'
+
+# scheduler
+
+
+s = Rufus::Scheduler.start_new
+
+puts Time.now.to_s
+
+s.in('1s') do
+  p [ :in, Time.now.to_s ]
+  exit 0
+end
+
+s.join
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rufus-scheduler
 version: !ruby/object:Gem::Version 
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors: 
 - John Mettraux
@@ -9,10 +9,39 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-05 00:00:00 +09:00
+date: 2010-02-12 00:00:00 +09:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: "\n    job scheduler for Ruby (at, cron, in and every jobs).\n\n    By default uses a Ruby thread, if EventMachine is present, it will rely on it.\n  "
 email: jmettraux@gmail.com
 executables: []
@@ -20,11 +49,16 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
+- LICENSE.txt
 - README.rdoc
+files: 
 - CHANGELOG.txt
 - CREDITS.txt
 - LICENSE.txt
-files: 
+- README.rdoc
+- Rakefile
+- TODO.txt
+- lib/rufus-scheduler.rb
 - lib/rufus/otime.rb
 - lib/rufus/sc/cronline.rb
 - lib/rufus/sc/jobqueues.rb
@@ -32,19 +66,32 @@ files:
 - lib/rufus/sc/rtime.rb
 - lib/rufus/sc/scheduler.rb
 - lib/rufus/scheduler.rb
-- lib/rufus-scheduler.rb
-- CHANGELOG.txt
-- CREDITS.txt
-- LICENSE.txt
-- TODO.txt
-- README.rdoc
+- misc/cronline_next_time_cost.rb
+- rufus-scheduler.gemspec
+- spec/at_in_spec.rb
+- spec/at_spec.rb
+- spec/blocking_spec.rb
+- spec/cron_spec.rb
+- spec/cronline_spec.rb
+- spec/every_spec.rb
+- spec/exception_spec.rb
+- spec/in_spec.rb
+- spec/rtime_spec.rb
+- spec/schedulable_spec.rb
+- spec/scheduler_spec.rb
+- spec/spec.rb
+- spec/spec_base.rb
+- spec/stress_schedule_unschedule_spec.rb
+- spec/timeout_spec.rb
+- test/kjw.rb
+- test/t.rb
 has_rdoc: true
-homepage: http://github.com/jmettraux/rufus-scheduler
+homepage: http://github.com/jmettraux/rufus-scheduler/
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement