sskirby-resque-scheduler 1.10.9 → 1.10.13

data/lib/resque/scheduler.rb

@@ -25,11 +25,12 @@ module Resque
 
       # Schedule all jobs and continually look for delayed jobs (never returns)
       def run
-
+        $0 = "resque-scheduler: Starting"
         # trap signals
         register_signal_handlers
 
         # Load the schedule into rufus
+        procline "Loading Schedule"
         load_schedule!
 
         # Now start the scheduling part of the loop.
@@ -68,6 +69,8 @@ module Resque
         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
@@ -78,13 +81,24 @@ module Resque
         # to.
         if config['rails_env'].nil? || rails_env_matches?(config)
           log! "Scheduling #{name} "
-          if !config['cron'].nil? && config['cron'].length > 0
-            @@scheduled_jobs[name] = rufus_scheduler.cron config['cron'] do
-              log! "queuing #{config['class']} (#{name})"
-              enqueue_from_config(config)
+          interval_defined = false
+          interval_types = %w{cron every}
+          interval_types.each do |interval_type|
+            if !config[interval_type].nil? && config[interval_type].length > 0
+              begin
+                @@scheduled_jobs[name] = rufus_scheduler.send(interval_type, config[interval_type]) do
+                  log! "queueing #{config['class']} (#{name})"
+                  enqueue_from_config(config)
+                end
+              rescue Exception => e
+                log! "#{e.class.name}: #{e.message}"
+              end
+              interval_defined = true
+              break
             end
-          else
-            log! "no cron found for #{config['class']} (#{name}) - skipping"
+          end
+          unless interval_defined
+            log! "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
           end
         end
       end
@@ -96,14 +110,14 @@ module Resque
       end
 
       # Handles queueing delayed items
-      def handle_delayed_items
-        item = nil
-        begin
-          if timestamp = Resque.next_delayed_timestamp
+      def handle_delayed_items(at_time = nil)
+        if timestamp = Resque.next_delayed_timestamp(at_time)
+          procline "Processing Delayed Items"
+          while !timestamp.nil?
             enqueue_delayed_items_for_timestamp(timestamp)
+            timestamp = Resque.next_delayed_timestamp(at_time)
           end
-        # continue processing until there are no more ready timestamps
-        end while !timestamp.nil?
+        end
       end
       
       # Enqueues all delayed jobs for a timestamp
@@ -164,32 +178,26 @@ module Resque
       end
       
       def reload_schedule!
-        log! "Reloading Schedule..."
+        procline "Reloading Schedule"
         clear_schedule!
         Resque.reload_schedule!
         load_schedule!
       end
       
       def update_schedule
-        schedule_from_redis = Resque.get_schedules
-        if !schedule_from_redis.nil? && schedule_from_redis != Resque.schedule
-          log "Updating schedule..."
-          # unload schedules that no longer exist
-          (Resque.schedule.keys - schedule_from_redis.keys).each do |name|
-            unschedule_job(name)
-          end
-          
-          # find changes and stop and reload or add new
-          schedule_from_redis.each do |name, config|
-            if (Resque.schedule[name].nil? || Resque.schedule[name].empty?) || (config != Resque.schedule[name])
-              unschedule_job(name)
-              load_schedule_job(name, config)
+        if Resque.redis.scard(:schedules_changed) > 0
+          procline "Updating schedule"
+          Resque.reload_schedule!
+          while schedule_name = Resque.redis.spop(:schedules_changed)
+            if Resque.schedule.keys.include?(schedule_name)
+              unschedule_job(schedule_name)
+              load_schedule_job(schedule_name, Resque.schedule[schedule_name])
+            else
+              unschedule_job(schedule_name)
             end
           end
-          
-          # load new schedule into Resque.schedule
-          Resque.schedule = schedule_from_redis
         end
+        procline "Schedules Loaded"
       end
       
       def unschedule_job(name)
@@ -222,6 +230,11 @@ module Resque
         # add "verbose" logic later
         log!(msg) if verbose
       end
+      
+      def procline(string)
+        $0 = "resque-scheduler-#{ResqueScheduler::Version}: #{string}"
+        log! $0
+      end
 
     end
 

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

@@ -10,7 +10,7 @@
     <th></th>
     <th>Name</th>
     <th>Description</th>
-    <th>Cron</th>
+    <th>Interval</th>
     <th>Class</th>
     <th>Queue</th>
     <th>Arguments</th>
@@ -26,7 +26,9 @@
       </td>
       <td><%= h name %></td>
       <td><%= h config['description'] %></td>
-      <td style="white-space:nowrap"><%= h config['cron'] %></td>
+      <td style="white-space:nowrap"><%= (config['cron'].nil? && !config['every'].nil?) ?
+                                         h('every: ' + config['every']) : 
+                                         h('cron: ' + config['cron']) %></td>
       <td><%= h config['class'] %></td>
       <td><%= h config['queue'] || queue_from_class_name(config['class']) %></td>
       <td><%= h config['args'].inspect %></td>

data/lib/resque_scheduler/version.rb

@@ -1,3 +1,3 @@
 module ResqueScheduler
-  Version = '1.10.9'
+  Version = '1.10.13'
 end

data/lib/resque_scheduler.rb

@@ -18,6 +18,8 @@ module ResqueScheduler
   #
   # :name can be anything and is used only to describe 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.
   # :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)
@@ -26,6 +28,11 @@ module ResqueScheduler
   #   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|
+        set_schedule(name, job_spec)
+      end
+    end
     @schedule = schedule_hash
   end
 
@@ -54,7 +61,12 @@ module ResqueScheduler
   
   # create or update a schedule with the provided name and configuration
   def set_schedule(name, config)
-    redis.hset(:schedules, name, encode(config))
+    existing_config = get_schedule(name)
+    unless existing_config && existing_config == config
+      redis.hset(:schedules, name, encode(config))
+      redis.sadd(:schedules_changed, name)
+    end
+    config
   end
   
   # retrive the schedule configuration for the given name
@@ -65,6 +77,7 @@ module ResqueScheduler
   # remove a given schedule by name
   def remove_schedule(name)
     redis.hdel(:schedules, name)
+    redis.sadd(:schedules_changed, name)
   end
 
   # This method is nearly identical to +enqueue+ only it also
@@ -122,8 +135,8 @@ module ResqueScheduler
 
   # Returns the next delayed queue timestamp
   # (don't call directly)
-  def next_delayed_timestamp
-    items = redis.zrangebyscore :delayed_queue_schedule, '-inf', Time.now.to_i, :limit => [0, 1]
+  def next_delayed_timestamp(at_time=nil)
+    items = redis.zrangebyscore :delayed_queue_schedule, '-inf', (at_time || Time.now).to_i, :limit => [0, 1]
     timestamp = items.nil? ? nil : Array(items).first
     timestamp.to_i unless timestamp.nil?
   end

data/sskirby-resque-scheduler.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sskirby-resque-scheduler}
-  s.version = "1.10.9"
+  s.version = "1.10.13"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben VandenBos", "Brian Landau", "Sean Kirby", "Tanzeeb Khalili"]
-  s.date = %q{2010-11-02}
+  s.date = %q{2011-08-31}
   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.}

data/test/delayed_queue_test.rb

@@ -50,6 +50,16 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_nil(read_timestamp, "No timestamps should be ready for queueing")
   end
 
+  def test_something_in_the_future_comes_out_if_you_want_it_to
+    timestamp = Time.now + 600 # 10 minutes from now
+
+    Resque.enqueue_at(timestamp, SomeIvarJob, "path")
+
+    read_timestamp = Resque.next_delayed_timestamp(timestamp)
+
+    assert_equal(timestamp.to_i, read_timestamp, "The timestamp we pull out of redis should match the one we put in")
+  end
+
   def test_enqueue_at_and_enqueue_in_are_equivelent
     timestamp = Time.now + 60
 
@@ -120,6 +130,17 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     Resque.expects(:queue_from_class).never # Should NOT need to load the class
     Resque::Scheduler.handle_delayed_items
   end
+
+  def test_handle_delayed_items_with_items_in_the_future
+    t = Time.now + 60 # in the future
+    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::Scheduler.handle_delayed_items(t)
+  end
   
   def test_enqueue_delayed_items_for_timestamp
     t = Time.now + 60

data/test/scheduler_test.rb

@@ -7,12 +7,19 @@ class Resque::SchedulerTest < Test::Unit::TestCase
   end
 
   def setup
+    Resque::Scheduler.dynamic = false
     Resque.redis.del(:schedules)
+    Resque.redis.del(:schedules_changed)
     Resque::Scheduler.mute = true
     Resque::Scheduler.clear_schedule!
     Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
   end
 
+  def test_enqueue_from_config_with_every_syntax
+    Resque::Job.stubs(:create).once.returns(true).with('james_queue', SomeIvarJob, '/tmp')
+    Resque::Scheduler.enqueue_from_config('every' => '1m', 'class' => 'SomeIvarJob', 'args' => '/tmp', 'queue' => 'james_queue')
+  end
+
   def test_enqueue_from_config_puts_stuff_in_the_resque_queue
     Resque::Job.stubs(:create).once.returns(true).with(:ivar, SomeIvarJob, '/tmp')
     Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp")
@@ -72,10 +79,8 @@ class Resque::SchedulerTest < Test::Unit::TestCase
   end
   
   def test_can_reload_schedule
+    Resque::Scheduler.dynamic = true
     Resque.schedule = {"some_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
-    Resque.redis.hset(:schedules, "some_ivar_job", Resque.encode(
-      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}
-    ))
   
     Resque::Scheduler.load_schedule!
 
@@ -120,6 +125,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
   end
   
   def test_update_schedule
+    Resque::Scheduler.dynamic = true
     Resque.schedule = {
       "some_ivar_job"    => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"},
       "another_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/5"},
@@ -128,15 +134,16 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     
     Resque::Scheduler.load_schedule!
     
-    Resque.redis.hset(:schedules, "some_ivar_job", Resque.encode(
+    Resque.set_schedule("some_ivar_job",
       {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"}
-    ))
-    Resque.redis.hset(:schedules, "new_ivar_job", Resque.encode(
+    )
+    Resque.set_schedule("new_ivar_job",
       {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
-    ))
-    Resque.redis.hset(:schedules, "stay_put_job", Resque.encode(
+    )
+    Resque.set_schedule("stay_put_job",
       {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp"}
-    ))
+    )
+    Resque.remove_schedule("another_ivar_job")
     
     Resque::Scheduler.update_schedule
     
@@ -148,9 +155,11 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     end
     assert !Resque::Scheduler.scheduled_jobs.keys.include?("another_ivar_job")
     assert !Resque.schedule.keys.include?("another_ivar_job")
+    assert_equal 0, Resque.redis.scard(:schedules_changed)
   end
   
   def test_update_schedule_with_mocks
+    Resque::Scheduler.dynamic = true
     Resque.schedule = {
       "some_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"},
       "another_ivar_job"  => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/5"},
@@ -162,15 +171,16 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     Resque::Scheduler.rufus_scheduler.expects(:unschedule).with(Resque::Scheduler.scheduled_jobs["some_ivar_job"].job_id)
     Resque::Scheduler.rufus_scheduler.expects(:unschedule).with(Resque::Scheduler.scheduled_jobs["another_ivar_job"].job_id)
     
-    Resque.redis.hset(:schedules, "some_ivar_job", Resque.encode(
+    Resque.set_schedule("some_ivar_job",
       {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"}
-    ))
-    Resque.redis.hset(:schedules, "new_ivar_job", Resque.encode(
+    )
+    Resque.set_schedule("new_ivar_job",
       {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
-    ))
-    Resque.redis.hset(:schedules, "stay_put_job", Resque.encode(
+    )
+    Resque.set_schedule("stay_put_job",
       {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp"}
-    ))
+    )
+    Resque.remove_schedule("another_ivar_job")
     
     Resque::Scheduler.update_schedule
     
@@ -181,6 +191,16 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     end
     assert !Resque::Scheduler.scheduled_jobs.keys.include?("another_ivar_job")
     assert !Resque.schedule.keys.include?("another_ivar_job")
+    assert_equal 0, Resque.redis.scard(:schedules_changed)
+  end
+  
+  def test_set_schedules
+    Resque::Scheduler.dynamic = true
+    Resque.schedule = {"my_ivar_job" => {
+      'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/75"
+    }}
+    assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/75"}, 
+      Resque.decode(Resque.redis.hget(:schedules, "my_ivar_job")))
   end
   
   def test_set_schedule
@@ -189,6 +209,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     })
     assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/22"}, 
       Resque.decode(Resque.redis.hget(:schedules, "some_ivar_job")))
+    assert Resque.redis.sismember(:schedules_changed, "some_ivar_job")
   end
   
   def test_get_schedule
@@ -205,11 +226,13 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     ))
     Resque.remove_schedule("some_ivar_job3")
     assert_equal nil, Resque.redis.hget(:schedules, "some_ivar_job3")
+    assert Resque.redis.sismember(:schedules_changed, "some_ivar_job3")
   end
 
   def test_adheres_to_lint
     assert_nothing_raised do
       Resque::Plugin.lint(Resque::Scheduler)
+      Resque::Plugin.lint(ResqueScheduler)
     end
   end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 10
-  - 9
-  version: 1.10.9
+  - 13
+  version: 1.10.13
 platform: ruby
 authors: 
 - Ben VandenBos
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-02 00:00:00 -04:00
+date: 2011-08-31 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency