rufus-scheduler 2.0.24 → 3.1.0

data/spec/stress_schedule_unschedule_spec.rb

@@ -1,159 +0,0 @@
-
-#
-# a spec by Klaas Jan Wierenga
-#
-
-require '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 == scheduler.find_jobs.map{ |job| job.job_id }.sort
-    JOB_COUNT.should satisfy &eventually { @trigger_queue.size }
-    @trigger_queue.size.should == 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 == scheduler.find_jobs.map{ |job| job.job_id }.sort
-    JOB_COUNT.should satisfy &eventually { @trigger_queue.size }
-    @trigger_queue.size.should == 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(: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(:each) do
-    @trigger_queue = nil
-  end
-
-  it "sustains frequent schedule/unschedule 'cron' jobs with same ids" do
-    schedule_unschedule_same_ids_spec(:cron)
-  end
-
-  it "sustains frequent schedule/unschedule 'at' jobs with same ids" do
-    schedule_unschedule_same_ids_spec(:at)
-  end
-
-  it "sustains frequent schedule/unschedule 'every' jobs same ids" do
-    schedule_unschedule_same_ids_spec(:every)
-  end
-
-  it "sustains frequent schedule/unschedule 'cron' jobs with unique ids" do
-    schedule_unschedule_unique_ids_spec(:cron)
-  end
-
-  it "sustains frequent schedule/unschedule 'at' jobs with unique ids" do
-    schedule_unschedule_unique_ids_spec(:at)
-  end
-
-  it "sustains frequent schedule/unschedule 'every' jobs unique ids" do
-    schedule_unschedule_unique_ids_spec(:every)
-  end
-end
-

data/spec/timeout_spec.rb

@@ -1,148 +0,0 @@
-
-#
-# Specifying rufus-scheduler
-#
-# Sun May  3 15:44:28 JST 2009
-#
-
-require 'spec_base'
-
-
-describe "#{SCHEDULER_CLASS} timeouts" do
-
-  before(:each) do
-    @s = start_scheduler
-  end
-  after(:each) do
-    stop_scheduler(@s)
-  end
-
-  it 'refuses to schedule a job with :timeout and :blocking' do
-
-    lambda {
-      @s.in '1s', :timeout => '3s', :blocking => true do
-      end
-    }.should raise_error(ArgumentError)
-  end
-
-  it 'schedules a dedicated job for the timeout' do
-
-    @s.in '1s', :timeout => '3s' do
-      sleep 5
-    end
-
-    @s.jobs.size.should == 1
-
-    # the timeout job is left
-
-    sleep 2
-    @s.jobs.size.should == 1
-    @s.find_by_tag('timeout').size.should == 1
-  end
-
-  it 'times 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 == nil
-    @s.jobs.size.should == 0
-    timedout.should == true
-  end
-
-  it 'dies 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 == true
-    @s.jobs.size.should == 0
-    timedout.should == false
-  end
-
-  it 'does 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.5
-
-    timeouts.size.should == 3
-    timeouts.each { |to| to.should be_within(0.5).of(1.5) }
-  end
-
-  it 'points to their "parent" job' do
-
-    @s.in '1s', :timeout => '3s', :job_id => 'nada' do
-      sleep 4
-    end
-
-    sleep 2
-
-    @s.jobs.values.first.parent.job_id.should == 'nada'
-  end
-
-  it 'does not survive their job' do
-
-    @s.in '1s', :timeout => '3s' do
-      sleep 0.100
-    end
-
-    sleep 2
-
-    @s.jobs.size.should == 0
-  end
-
-  it 'times out properly after waiting for a mutex' do
-
-    mutex = Mutex.new
-    timedout = false
-
-    @s.in '0s', :mutex => mutex do
-      sleep 1
-    end
-
-    @s.in '0s', :mutex => mutex, :timeout => 0.1 do
-      begin
-        sleep 2
-      rescue Rufus::Scheduler::TimeOutError => e
-        timedout = true
-      end
-    end
-
-    sleep 2
-
-    @s.jobs.size.should == 0
-    timedout.should be_true
-  end
-end
-

data/test/kjw.rb

@@ -1,113 +0,0 @@
-#!/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

@@ -1,20 +0,0 @@
-
-$:.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
-