resque-scheduler 2.0.0.d → 2.0.0.e

data/Rakefile

@@ -1,4 +1,5 @@
 require 'bundler'
+require 'rake/rdoctask'
 Bundler::GemHelper.install_tasks
 
 $LOAD_PATH.unshift 'lib'
@@ -11,3 +12,10 @@ task :test do
     require File.expand_path(f)
   end
 end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.markdown"
+  rd.rdoc_files.include("README.markdown", "lib/**/*.rb")
+  rd.rdoc_dir = 'doc'
+end
+

data/lib/resque/scheduler.rb

@@ -11,17 +11,25 @@ module Resque
 
       # If true, logs more stuff...
       attr_accessor :verbose
-      
+
       # If set, produces no output
       attr_accessor :mute
-      
+
       # If set, will try to update the schulde in the loop
       attr_accessor :dynamic
       
+      # Amount of time in seconds to sleep between polls of the delayed
+      # queue.  Defaults to 5
+      attr_writer :poll_sleep_amount
+
       # the Rufus::Scheduler jobs that are scheduled
       def scheduled_jobs
         @@scheduled_jobs
       end
+      
+      def poll_sleep_amount
+        @poll_sleep_amount ||= 5 # seconds
+      end
 
       # Schedule all jobs and continually look for delayed jobs (never returns)
       def run
@@ -30,8 +38,12 @@ module Resque
         register_signal_handlers
 
         # Load the schedule into rufus
-        procline "Loading Schedule"
-        load_schedule!
+        # If dynamic is set, load that schedule otherwise use normal load
+        if dynamic
+          reload_schedule!
+        else
+          load_schedule!
+        end
 
         # Now start the scheduling part of the loop.
         loop do
@@ -53,33 +65,45 @@ module Resque
       def register_signal_handlers
         trap("TERM") { shutdown }
         trap("INT") { shutdown }
-        
+
         begin
-          trap('QUIT') { shutdown   }
-          trap('USR1') { kill_child }
+          trap('QUIT') { shutdown }
+          trap('USR1') { print_schedule }
           trap('USR2') { reload_schedule! }
         rescue ArgumentError
           warn "Signals QUIT and USR1 and USR2 not supported."
         end
       end
 
+      def print_schedule 
+        if rufus_scheduler
+          log! "Scheduling Info\tLast Run"
+          scheduler_jobs = rufus_scheduler.all_jobs
+          scheduler_jobs.each do |k, v|
+            log! "#{v.t}\t#{v.last}\t"
+          end
+        end
+      end
+
       # Pulls the schedule from Resque.schedule and loads it into the
       # rufus scheduler instance
       def load_schedule!
+        procline "Loading Schedule"
+         
         # Need to load the schedule from redis for the first time if dynamic
-        Resque.reload_schedule! if dynamic 
-        
+        Resque.reload_schedule! if dynamic
+
         log! "Schedule empty! Set Resque.schedule" if Resque.schedule.empty?
-        
+
         @@scheduled_jobs = {}
-        
+
         Resque.schedule.each do |name, config|
           load_schedule_job(name, config)
         end
         Resque.redis.del(:schedules_changed)
         procline "Schedules Loaded"
       end
-      
+
       # Loads a job schedule into the Rufus::Scheduler and stores it in @@scheduled_jobs
       def load_schedule_job(name, config)
         # If rails_env is set in the config, enforce ENV['RAILS_ENV'] as
@@ -128,7 +152,7 @@ module Resque
           end
         end
       end
-      
+
       # Enqueues all delayed jobs for a timestamp
       def enqueue_delayed_items_for_timestamp(timestamp)
         item = nil
@@ -152,9 +176,12 @@ module Resque
       # Enqueues a job based on a config hash
       def enqueue_from_config(job_config)
         args = job_config['args'] || job_config[:args]
+
         klass_name = job_config['class'] || job_config[:class]
+        klass = constantize(klass_name) rescue klass_name
+
         params = args.is_a?(Hash) ? [args] : Array(args)
-        queue = job_config['queue'] || job_config[:queue] || Resque.queue_from_class(constantize(klass_name))
+        queue = job_config['queue'] || job_config[:queue] || Resque.queue_from_class(klass)
         # Support custom job classes like those that inherit from Resque::JobWithStatus (resque-status)
         if (job_klass = job_config['custom_job_class']) && (job_klass != 'Resque::Job')
           # The custom job class API must offer a static "scheduled" method. If the custom
@@ -167,7 +194,14 @@ module Resque
             Resque::Job.create(queue, job_klass, *params)
           end
         else
-          Resque::Job.create(queue, klass_name, *params)
+          # hack to avoid havoc for people shoving stuff into queues
+          # for non-existent classes (for example: running scheduler in
+          # one app that schedules for another
+          if Class === klass
+            Resque.enqueue(klass, *params)
+          else
+            Resque::Job.create(queue, klass, *params)
+          end
         end
       rescue
         log! "Failed to enqueue #{klass_name}:\n #{$!}"
@@ -185,13 +219,13 @@ module Resque
         @@scheduled_jobs = {}
         rufus_scheduler
       end
-      
+
       def reload_schedule!
         procline "Reloading Schedule"
         clear_schedule!
         load_schedule!
       end
-      
+
       def update_schedule
         if Resque.redis.scard(:schedules_changed) > 0
           procline "Updating schedule"
@@ -207,7 +241,7 @@ module Resque
           procline "Schedules Loaded"
         end
       end
-      
+
       def unschedule_job(name)
         if scheduled_jobs[name]
           log "Removing schedule #{name}"
@@ -219,7 +253,7 @@ module Resque
       # Sleeps and returns true
       def poll_sleep
         @sleeping = true
-        handle_shutdown { sleep 5 }
+        handle_shutdown { sleep poll_sleep_amount }
         @sleeping = false
         true
       end
@@ -238,7 +272,7 @@ module Resque
         # add "verbose" logic later
         log!(msg) if verbose
       end
-      
+
       def procline(string)
         log! string
         $0 = "resque-scheduler-#{ResqueScheduler::Version}: #{string}"

data/lib/resque_scheduler.rb

@@ -10,23 +10,31 @@ module ResqueScheduler
   #
   # Accepts a new schedule configuration of the form:
   #
-  #   {some_name => {"cron" => "5/* * * *",
-  #                  "class" => DoSomeWork,
+  #   {'some_name' => {"cron" => "5/* * * *",
+  #                  "class" => "DoSomeWork",
   #                  "args" => "work on this string",
   #                  "description" => "this thing works it"s butter off"},
   #    ...}
   #
-  # :name can be anything and is used only to describe the scheduled job
+  # 'some_name' can be anything and is used only to describe and reference 
+  # the scheduled job
+  #
   # :cron can be any cron scheduling string :job can be any resque job class
-  # :every can be used in lieu of :cron. see rufus-scheduler's 'every' usage for 
-  #   valid syntax. If :cron is present it will take precedence over :every.
+  #
+  # :every can be used in lieu of :cron. see rufus-scheduler's 'every' usage
+  # for valid syntax. If :cron is present it will take precedence over :every.
+  #
   # :class must be a resque worker class
-  # :args can be any yaml which will be converted to a ruby literal and passed
-  #   in a params. (optional)
-  # :rails_envs is the list of envs where the job gets loaded. Envs are comma separated (optional)
-  # :description is just that, a description of the job (optional). If params is
-  #   an array, each element in the array is passed as a separate param,
-  #   otherwise params is passed in as the only parameter to perform.
+  #
+  # :args can be any yaml which will be converted to a ruby literal and
+  # passed in a params. (optional)
+  #
+  # :rails_envs is the list of envs where the job gets loaded. Envs are
+  # comma separated (optional)
+  #
+  # :description is just that, a description of the job (optional). If
+  # params is an array, each element in the array is passed as a separate
+  # param, otherwise params is passed in as the only parameter to perform.
   def schedule=(schedule_hash)
     if Resque::Scheduler.dynamic
       schedule_hash.each do |name, job_spec|
@@ -59,7 +67,15 @@ module ResqueScheduler
     end
   end
   
-  # create or update a schedule with the provided name and configuration
+  # Create or update a schedule with the provided name and configuration.
+  #
+  # Note: values for class and custom_job_class need to be strings,
+  # not constants.
+  #  
+  #    Resque.set_schedule('some_job', {:class => 'SomeJob',
+  #                                     :every => '15mins',
+  #                                     :queue => 'high',
+  #                                     :args => '/tmp/poop'})
   def set_schedule(name, config)
     existing_config = get_schedule(name)
     unless existing_config && existing_config == config
@@ -89,12 +105,26 @@ module ResqueScheduler
     delayed_push(timestamp, job_to_hash(klass, args))
   end
 
+  # Identical to +enqueue_at+, except you can also specify
+  # a queue in which the job will be placed after the 
+  # timestamp has passed.
+  def enqueue_at_with_queue(queue, timestamp, klass, *args)
+    delayed_push(timestamp, job_to_hash_with_queue(queue, klass, args))
+  end
+
   # Identical to enqueue_at but takes number_of_seconds_from_now
   # instead of a timestamp.
   def enqueue_in(number_of_seconds_from_now, klass, *args)
     enqueue_at(Time.now + number_of_seconds_from_now, klass, *args)
   end
 
+  # Identical to +enqueue_in+, except you can also specify
+  # a queue in which the job will be placed after the 
+  # number of seconds has passed.
+  def enqueue_in_with_queue(queue, number_of_seconds_from_now, klass, *args)
+    enqueue_at_with_queue(queue, Time.now + number_of_seconds_from_now, klass, *args)
+  end
+
   # Used internally to stuff the item into the schedule sorted list.
   # +timestamp+ can be either in seconds or a datetime object
   # Insertion if O(log(n)).
@@ -183,9 +213,14 @@ module ResqueScheduler
   end 
 
   private
+  
     def job_to_hash(klass, args)
       {:class => klass.to_s, :args => args, :queue => queue_from_class(klass)}
     end
+    
+    def job_to_hash_with_queue(queue, klass, args)
+      {:class => klass.to_s, :args => args, :queue => queue}
+    end
 
     def clean_up_timestamp(key, timestamp)
       # If the list is empty, remove it.

data/lib/resque_scheduler/server.rb

@@ -45,6 +45,11 @@ module ResqueScheduler
           Resque::Scheduler.enqueue_delayed_items_for_timestamp(timestamp.to_i) if timestamp.to_i > 0
           redirect u("/overview")
         end
+        
+        post "/delayed/clear" do
+          Resque.reset_delayed_queue
+          redirect u('delayed')
+        end
 
       end
 

data/lib/resque_scheduler/server/views/delayed.erb

@@ -1,11 +1,17 @@
 <h1>Delayed Jobs</h1>
+<%- size = resque.delayed_queue_schedule_size %>
+<% if size > 0 %>
+  <form method="POST" action="<%=u 'delayed/clear'%>" class='clear-delayed'>
+    <input type='submit' name='' value='Clear Delayed Jobs' />
+  </form>
+<% end %>
 
 <p class='intro'>
   This list below contains the timestamps for scheduled delayed jobs.
 </p>
 
 <p class='sub'>
-  Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%=size = resque.delayed_queue_schedule_size %></b> timestamps
+  Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%= size %></b> timestamps
 </p>
 
 <table>
@@ -16,7 +22,7 @@
     <th>Class</th>
     <th>Args</th>
   </tr>
-  <% resque.delayed_queue_peek(start, start+20).each do |timestamp| %>
+  <% resque.delayed_queue_peek(start, 20).each do |timestamp| %>
     <tr>
       <td>
         <form action="<%= u "/delayed/queue_now" %>" method="post">

data/lib/resque_scheduler/tasks.rb

@@ -11,6 +11,7 @@ namespace :resque do
 
     File.open(ENV['PIDFILE'], 'w') { |f| f << Process.pid.to_s } if ENV['PIDFILE']
 
+    Resque::Scheduler.dynamic = true if ENV['DYNAMIC_SCHEDULE']
     Resque::Scheduler.verbose = true if ENV['VERBOSE']
     Resque::Scheduler.run
   end
@@ -23,4 +24,4 @@ namespace :resque do
     end
   end
 
-end
+end

data/lib/resque_scheduler/version.rb

@@ -1,3 +1,3 @@
 module ResqueScheduler
-  Version = '2.0.0.d'
+  Version = '2.0.0.e'
 end

data/resque-scheduler.gemspec

@@ -12,18 +12,17 @@ Gem::Specification.new do |s|
   s.description = %q{Light weight job scheduling on top of Resque.
     Adds methods enqueue_at/enqueue_in to schedule jobs in the future.
     Also supports queueing jobs on a fixed, cron-like schedule.}
-  
+
   s.required_rubygems_version = ">= 1.3.6"
   s.add_development_dependency "bundler", ">= 1.0.0"
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
   s.require_path = 'lib'
-  
+
   s.add_runtime_dependency(%q<redis>, [">= 2.0.1"])
-  s.add_runtime_dependency(%q<resque>, [">= 1.8.0"])
+  s.add_runtime_dependency(%q<resque>, [">= 1.15.0"])
   s.add_runtime_dependency(%q<rufus-scheduler>, [">= 0"])
   s.add_development_dependency(%q<mocha>, [">= 0"])
   s.add_development_dependency(%q<rack-test>, [">= 0"])
-  
 end

data/test/delayed_queue_test.rb

@@ -28,7 +28,35 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     # Confirm the item came out correctly
     assert_equal('SomeIvarJob', item['class'], "Should be the same class that we queued")
     assert_equal(["path"], item['args'], "Should have the same arguments that we queued")
-    
+
+    # And now confirm the keys are gone
+    assert(!Resque.redis.exists("delayed:#{timestamp.to_i}"))
+    assert_equal(0, Resque.redis.zcard(:delayed_queue_schedule), "delayed queue should be empty")
+  end
+
+  def test_enqueue_at_with_queue_adds_correct_list_and_zset_and_queue
+
+    timestamp = Time.now - 1 # 1 second ago (in the past, should come out right away)
+
+    assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
+
+    Resque.enqueue_at_with_queue('critical', timestamp, SomeIvarJob, "path")
+
+    # Confirm the correct keys were added
+    assert_equal(1, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should have one entry now")
+    assert_equal(1, Resque.redis.zcard(:delayed_queue_schedule), "The delayed_queue_schedule should have 1 entry now")
+
+    read_timestamp = Resque.next_delayed_timestamp
+
+    # Confirm the timestamp came out correctly
+    assert_equal(timestamp.to_i, read_timestamp, "The timestamp we pull out of redis should match the one we put in")
+    item = Resque.next_item_for_timestamp(read_timestamp)
+
+    # Confirm the item came out correctly
+    assert_equal('SomeIvarJob', item['class'], "Should be the same class that we queued")
+    assert_equal(["path"], item['args'], "Should have the same arguments that we queued")
+    assert_equal('critical', item['queue'], "Should have the queue that we asked for")
+
     # And now confirm the keys are gone
     assert(!Resque.redis.exists("delayed:#{timestamp.to_i}"))
     assert_equal(0, Resque.redis.zcard(:delayed_queue_schedule), "delayed queue should be empty")
@@ -126,8 +154,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     Resque.enqueue_at(t, SomeIvarJob)
 
     # 2 SomeIvarJob jobs should be created in the "ivar" queue
-    Resque::Job.expects(:create).twice.with('ivar', 'SomeIvarJob', nil)
-    Resque.expects(:queue_from_class).never # Should NOT need to load the class
+    Resque::Job.expects(:create).twice.with(:ivar, SomeIvarJob, nil)
     Resque::Scheduler.handle_delayed_items
   end
 
@@ -137,23 +164,21 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     Resque.enqueue_at(t, SomeIvarJob)
 
     # 2 SomeIvarJob jobs should be created in the "ivar" queue
-    Resque::Job.expects(:create).twice.with('ivar', 'SomeIvarJob', nil)
-    Resque.expects(:queue_from_class).never # Should NOT need to load the class
+    Resque::Job.expects(:create).twice.with(:ivar, SomeIvarJob, nil)
     Resque::Scheduler.handle_delayed_items(t)
   end
-  
+
   def test_enqueue_delayed_items_for_timestamp
     t = Time.now + 60
-    
+
     Resque.enqueue_at(t, SomeIvarJob)
     Resque.enqueue_at(t, SomeIvarJob)
 
     # 2 SomeIvarJob jobs should be created in the "ivar" queue
-    Resque::Job.expects(:create).twice.with('ivar', 'SomeIvarJob', nil)
-    Resque.expects(:queue_from_class).never # Should NOT need to load the class
+    Resque::Job.expects(:create).twice.with(:ivar, SomeIvarJob, nil)
 
     Resque::Scheduler.enqueue_delayed_items_for_timestamp(t)
-    
+
     # delayed queue for timestamp should be empty
     assert_equal(0, Resque.delayed_timestamp_peek(t, 0, 3).length)
   end
@@ -165,7 +190,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     # Since we didn't specify :queue when calling delayed_push, it will be forced
     # to load the class to figure out the queue.  This is the upgrade case from 1.0.4
     # to 1.0.5.
-    Resque::Job.expects(:create).once.with(:ivar, 'SomeIvarJob', nil)
+    Resque::Job.expects(:create).once.with(:ivar, SomeIvarJob, nil)
 
     Resque::Scheduler.handle_delayed_items
   end
@@ -206,7 +231,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(2, Resque.remove_delayed(SomeIvarJob, "bar"))
     assert_equal(1, Resque.delayed_queue_schedule_size)
   end
-  
+
   def test_remove_specific_item_in_group_of_other_items_at_different_timestamps
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob, "foo")