tanzeeb-rufus-scheduler 2.0.7.2

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,125 @@
+
+#
+# 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
+
+  it 'should point 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.equal('nada')
+  end
+
+  it 'should not survive their job' do
+
+    @s.in '1s', :timeout => '3s' do
+      sleep 0.100
+    end
+
+    sleep 2
+
+    @s.jobs.size.should.equal(0)
+  end
+end
+

data/tanzeeb-rufus-scheduler.gemspec

@@ -0,0 +1,97 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{tanzeeb-rufus-scheduler}
+  s.version = "2.0.7.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["John Mettraux", "Tanzeeb Khalili", "Matt Briggs", "Sean Kirby"]
+  s.date = %q{2010-11-02}
+  s.description = %q{
+    job scheduler for Ruby (at, cron, in and every jobs).
+
+    By default uses a Ruby thread, if EventMachine is present, it will rely on it.
+
+    This fork adds timezone support to cron schedules.
+  }
+  s.email = %q{tanzeeb@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG.txt",
+     "CREDITS.txt",
+     "LICENSE.txt",
+     "README.rdoc",
+     "Rakefile",
+     "TODO.txt",
+     "lib/rufus-scheduler.rb",
+     "lib/rufus/otime.rb",
+     "lib/rufus/sc/cronline.rb",
+     "lib/rufus/sc/jobqueues.rb",
+     "lib/rufus/sc/jobs.rb",
+     "lib/rufus/sc/rtime.rb",
+     "lib/rufus/sc/scheduler.rb",
+     "lib/rufus/sc/version.rb",
+     "lib/rufus/scheduler.rb",
+     "misc/cronline_next_time_cost.rb",
+     "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",
+     "tanzeeb-rufus-scheduler.gemspec",
+     "test/kjw.rb",
+     "test/t.rb"
+  ]
+  s.homepage = %q{http://github.com/tanzeeb/rufus-scheduler/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rufus}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{job scheduler for Ruby (at, cron, in and every jobs)}
+  s.test_files = [
+    "spec/spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<bacon>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_runtime_dependency(%q<tzinfo>, [">= 0"])
+    else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<bacon>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<tzinfo>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<bacon>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<tzinfo>, [">= 0"])
+  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
+