ealdent-resque-scheduler 2.0.0.e

data/lib/resque_scheduler/server.rb

@@ -0,0 +1,63 @@
+
+# Extend Resque::Server to add tabs
+module ResqueScheduler
+  
+  module Server
+
+    def self.included(base)
+
+      base.class_eval do
+
+        helpers do
+          def format_time(t)
+            t.strftime("%Y-%m-%d %H:%M:%S %z")
+          end
+
+          def queue_from_class_name(class_name)
+            Resque.queue_from_class(Resque.constantize(class_name))
+          end
+        end
+
+        get "/schedule" do
+          Resque.reload_schedule! if Resque::Scheduler.dynamic
+          # Is there a better way to specify alternate template locations with sinatra?
+          erb File.read(File.join(File.dirname(__FILE__), 'server/views/scheduler.erb'))
+        end
+
+        post "/schedule/requeue" do
+          config = Resque.schedule[params['job_name']]
+          Resque::Scheduler.enqueue_from_config(config)
+          redirect u("/overview")
+        end
+        
+        get "/delayed" do
+          # Is there a better way to specify alternate template locations with sinatra?
+          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed.erb'))
+        end
+
+        get "/delayed/:timestamp" do
+          # Is there a better way to specify alternate template locations with sinatra?
+          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed_timestamp.erb'))
+        end
+        
+        post "/delayed/queue_now" do
+          timestamp = params['timestamp']
+          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
+
+    end
+
+    Resque::Server.tabs << 'Schedule'
+    Resque::Server.tabs << 'Delayed'
+
+  end
+  
+end

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

@@ -0,0 +1,48 @@
+<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 %></b> timestamps
+</p>
+
+<table>
+  <tr>
+    <th></th>
+    <th>Timestamp</th>
+    <th>Job count</th>
+    <th>Class</th>
+    <th>Args</th>
+  </tr>
+  <% resque.delayed_queue_peek(start, 20).each do |timestamp| %>
+    <tr>
+      <td>
+        <form action="<%= u "/delayed/queue_now" %>" method="post">
+          <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
+          <input type="submit" value="Queue now">
+        </form>
+      </td>
+      <td><a href="<%= u "delayed/#{timestamp}" %>"><%= format_time(Time.at(timestamp)) %></a></td>
+      <td><%= delayed_timestamp_size = resque.delayed_timestamp_size(timestamp) %></td>
+      <% job = resque.delayed_timestamp_peek(timestamp, 0, 1).first %>
+      <td>
+        <% if job && delayed_timestamp_size == 1 %>
+          <%= h(job['class']) %>
+        <% else %>
+          <a href="<%= u "delayed/#{timestamp}" %>">see details</a>
+        <% end %>
+      </td>
+      <td><%= h(job['args'].inspect) if job && delayed_timestamp_size == 1 %></td>
+    </tr>
+  <% end %>
+</table>
+
+<%= partial :next_more, :start => start, :size => size %>

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

@@ -0,0 +1,26 @@
+<% timestamp = params[:timestamp].to_i %>
+
+<h1>Delayed jobs scheduled for <%= format_time(Time.at(timestamp)) %></h1>
+
+<p class='sub'>Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%=size = resque.delayed_timestamp_size(timestamp)%></b> jobs</p>
+
+<table class='jobs'>
+  <tr>
+    <th>Class</th>
+    <th>Args</th>
+  </tr>
+  <% jobs = resque.delayed_timestamp_peek(timestamp, start, 20) %>
+  <% jobs.each do |job| %>
+    <tr>
+      <td class='class'><%= job['class'] %></td>
+      <td class='args'><%=h job['args'].inspect %></td>
+    </tr>
+  <% end %>
+  <% if jobs.empty? %>
+    <tr>
+      <td class='no-data' colspan='2'>There are no pending jobs scheduled for this time.</td>
+    </tr>
+  <% end %>
+</table>
+
+<%= partial :next_more, :start => start, :size => size %>

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

@@ -0,0 +1,43 @@
+<h1>Schedule</h1>
+
+<p class='intro'>
+  The list below contains all scheduled jobs.  Click &quot;Queue now&quot; to queue
+  a job immediately.
+</p>
+
+<table>
+  <tr>
+    <th></th>
+    <th>Name</th>
+    <th>Description</th>
+    <th>Interval</th>
+    <th>Class</th>
+    <th>Queue</th>
+    <th>Arguments</th>
+  </tr>
+  <% Resque.schedule.keys.sort.each do |name| %>
+    <% config = Resque.schedule[name] %>
+    <tr>
+      <td>
+        <form action="<%= u "/schedule/requeue" %>" method="post">
+          <input type="hidden" name="job_name" value="<%= h name %>">
+          <input type="submit" value="Queue now">
+        </form>
+      </td>
+      <td><%= h name %></td>
+      <td><%= h config['description'] %></td>
+      <td style="white-space:nowrap"><%= if !config['every'].nil? 
+                                           h('every: ' + config['every'])
+                                         elsif !config['cron'].nil?
+                                           h('cron: ' + config['cron']) 
+                                         else
+                                           'Not currently scheduled'
+                                         end %></td>
+      <td><%= (config['class'].nil? && !config['custom_job_class'].nil?) ?
+              h(config['custom_job_class']) :
+              h(config['class']) %></td>
+      <td><%= h config['queue'] || queue_from_class_name(config['class']) %></td>
+      <td><%= h config['args'].inspect %></td>
+    </tr>
+  <% end %>
+</table>

data/lib/resque_scheduler/tasks.rb

@@ -0,0 +1,27 @@
+require 'resque/tasks'
+# will give you the resque tasks
+
+namespace :resque do
+  task :setup
+
+  desc "Start Resque Scheduler"
+  task :scheduler => :scheduler_setup do
+    require 'resque'
+    require 'resque_scheduler'
+
+    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
+
+  task :scheduler_setup do
+    if ENV['INITIALIZER_PATH']
+      load ENV['INITIALIZER_PATH'].to_s.strip
+    else
+      Rake::Task['resque:setup'].invoke
+    end
+  end
+
+end

data/lib/resque_scheduler/version.rb

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

data/resque-scheduler.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/resque_scheduler/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "ealdent-resque-scheduler"
+  s.version     = ResqueScheduler::Version
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Ben VandenBos']
+  s.email       = ['bvandenbos@gmail.com']
+  s.homepage    = "http://github.com/bvandenbos/resque-scheduler"
+  s.summary     = "Light weight job scheduling on top of Resque"
+  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.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/tasks/resque_scheduler.rake

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'resque_scheduler/tasks'

data/test/delayed_queue_test.rb

@@ -0,0 +1,254 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Resque::DelayedQueueTest < Test::Unit::TestCase
+
+  def setup
+    Resque::Scheduler.mute = true
+    Resque.redis.flushall
+  end
+
+  def test_enqueue_at_adds_correct_list_and_zset
+
+    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(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")
+
+    # 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")
+  end
+
+  def test_something_in_the_future_doesnt_come_out
+    timestamp = Time.now + 600 # 10 minutes from now (in the future, shouldn't come out)
+
+    assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
+
+    Resque.enqueue_at(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
+
+    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
+
+    Resque.enqueue_at(timestamp, SomeIvarJob, "path")
+    Resque.enqueue_in(timestamp - Time.now, SomeIvarJob, "path")
+
+    assert_equal(1, Resque.redis.zcard(:delayed_queue_schedule), "should have one timestamp in the delayed queue")
+    assert_equal(2, Resque.redis.llen("delayed:#{timestamp.to_i}"), "should have 2 items in the timestamp queue")
+  end
+
+  def test_empty_delayed_queue_peek
+    assert_equal([], Resque.delayed_queue_peek(0,20))
+  end
+
+  def test_delayed_queue_peek
+    t = Time.now
+    expected_timestamps = (1..5).to_a.map do |i|
+      (t + 60 + i).to_i
+    end
+
+    expected_timestamps.each do |timestamp|
+      Resque.delayed_push(timestamp, {:class => SomeIvarJob, :args => 'blah1'})
+    end
+
+    timestamps = Resque.delayed_queue_peek(2,3)
+
+    assert_equal(expected_timestamps[2,3], timestamps)
+  end
+
+  def test_delayed_queue_schedule_size
+    assert_equal(0, Resque.delayed_queue_schedule_size)
+    Resque.enqueue_at(Time.now+60, SomeIvarJob)
+    assert_equal(1, Resque.delayed_queue_schedule_size)
+  end
+
+  def test_delayed_timestamp_size
+    t = Time.now + 60
+    assert_equal(0, Resque.delayed_timestamp_size(t))
+    Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal(1, Resque.delayed_timestamp_size(t))
+    assert_equal(0, Resque.delayed_timestamp_size(t.to_i+1))
+  end
+
+  def test_delayed_timestamp_peek
+    t = Time.now + 60
+    assert_equal([], Resque.delayed_timestamp_peek(t, 0, 1), "make sure it's an empty array, not nil")
+    Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 1).length)
+    Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 1).length)
+    assert_equal(2, Resque.delayed_timestamp_peek(t, 0, 3).length)
+
+    assert_equal({'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}, Resque.delayed_timestamp_peek(t, 0, 1).first)
+  end
+
+  def test_handle_delayed_items_with_no_items
+    Resque::Scheduler.expects(:enqueue).never
+    Resque::Scheduler.handle_delayed_items
+  end
+
+  def test_handle_delayed_items_with_items
+    t = Time.now - 60 # in the past
+    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::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::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::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
+
+  def test_works_with_out_specifying_queue__upgrade_case
+    t = Time.now - 60
+    Resque.delayed_push(t, :class => 'SomeIvarJob')
+
+    # 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::Scheduler.handle_delayed_items
+  end
+
+  def test_clearing_delayed_queue
+    t = Time.now + 120
+    4.times { Resque.enqueue_at(t, SomeIvarJob) }
+    4.times { Resque.enqueue_at(Time.now + rand(100), SomeIvarJob) }
+
+    Resque.reset_delayed_queue
+    assert_equal(0, Resque.delayed_queue_schedule_size)
+  end
+
+  def test_remove_specific_item
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob)
+
+    assert_equal(1, Resque.remove_delayed(SomeIvarJob))
+  end
+
+  def test_remove_bogus_item_leaves_the_rest_alone
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    Resque.enqueue_at(t, SomeIvarJob, "bar")
+    Resque.enqueue_at(t, SomeIvarJob, "bar")
+    Resque.enqueue_at(t, SomeIvarJob, "baz")
+
+    assert_equal(0, Resque.remove_delayed(SomeIvarJob))
+  end
+
+  def test_remove_specific_item_in_group_of_other_items_at_same_timestamp
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    Resque.enqueue_at(t, SomeIvarJob, "bar")
+    Resque.enqueue_at(t, SomeIvarJob, "bar")
+    Resque.enqueue_at(t, SomeIvarJob, "baz")
+
+    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")
+    Resque.enqueue_at(t + 1, SomeIvarJob, "bar")
+    Resque.enqueue_at(t + 2, SomeIvarJob, "bar")
+    Resque.enqueue_at(t + 3, SomeIvarJob, "baz")
+
+    assert_equal(2, Resque.remove_delayed(SomeIvarJob, "bar"))
+    assert_equal(2, Resque.count_all_scheduled_jobs)
+  end
+
+  def test_invalid_job_class
+    assert_raise Resque::NoClassError do
+      Resque.enqueue_in(10, nil)
+    end
+    assert_raise Resque::NoQueueError do
+      Resque.enqueue_in(10, String) # string serves as invalid Job class
+    end
+  end
+end