resque-scheduler 2.0.0 → 2.3.1

data/lib/resque_scheduler.rb

@@ -1,11 +1,11 @@
 require 'rubygems'
 require 'resque'
 require 'resque_scheduler/version'
+require 'resque_scheduler/util'
 require 'resque/scheduler'
 require 'resque_scheduler/plugin'
 
 module ResqueScheduler
-
   #
   # Accepts a new schedule configuration of the form:
   #
@@ -25,6 +25,9 @@ module ResqueScheduler
   # is used implicitly as "class" argument - in the "MakeTea" example,
   # "MakeTea" is used both as job name and resque worker class.
   #
+  # Any jobs that were in the old schedule, but are not
+  # present in the new schedule, will be removed.
+  #
   # :cron can be any cron scheduling string
   #
   # :every can be used in lieu of :cron. see rufus-scheduler's 'every' usage
@@ -43,19 +46,27 @@ module ResqueScheduler
   # 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)
+    # clean the schedules as it exists in redis
+    clean_schedules
+
     schedule_hash = prepare_schedule(schedule_hash)
 
-    if Resque::Scheduler.dynamic
-      schedule_hash.each do |name, job_spec|
-        set_schedule(name, job_spec)
-      end
+    # store all schedules in redis, so we can retrieve them back everywhere.
+    schedule_hash.each do |name, job_spec|
+      set_schedule(name, job_spec)
     end
-    @schedule = schedule_hash
+
+    # ensure only return the successfully saved data!
+    reload_schedule!
   end
 
   # Returns the schedule hash
   def schedule
-    @schedule ||= {}
+    @schedule ||= get_schedules
+    if @schedule.nil?
+      return {}
+    end
+    @schedule
   end
 
   # reloads the schedule from redis
@@ -63,17 +74,28 @@ module ResqueScheduler
     @schedule = get_schedules
   end
 
-  # gets the schedule as it exists in redis
+  # gets the schedules as it exists in redis
   def get_schedules
+    unless redis.exists(:schedules)
+      return nil
+    end
+
+    redis.hgetall(:schedules).tap do |h|
+      h.each do |name, config|
+        h[name] = decode(config)
+      end
+    end
+  end
+
+  # clean the schedules as it exists in redis, useful for first setup?
+  def clean_schedules
     if redis.exists(:schedules)
-      redis.hgetall(:schedules).tap do |h|
-        h.each do |name, config|
-          h[name] = decode(config)
-        end
+      redis.hkeys(:schedules).each do |key|
+        remove_schedule(key)
       end
-    else
-      nil
     end
+    @schedule = nil
+    true
   end
 
   # Create or update a schedule with the provided name and configuration.
@@ -110,7 +132,7 @@ module ResqueScheduler
   # for queueing.  Until timestamp is in the past, the job will
   # sit in the schedule list.
   def enqueue_at(timestamp, klass, *args)
-    validate_job!(klass)
+    validate(klass)
     enqueue_at_with_queue(queue_from_class(klass), timestamp, klass, *args)
   end
 
@@ -121,9 +143,15 @@ module ResqueScheduler
   def enqueue_at_with_queue(queue, timestamp, klass, *args)
     return false unless Plugin.run_before_schedule_hooks(klass, *args)
 
-    if Resque.inline?
+    if Resque.inline? || timestamp.to_i < Time.now.to_i
       # Just create the job and let resque perform it right away with inline.
-      Resque::Job.create(queue, klass, *args)
+      # If the class is a custom job class, call self#scheduled on it. This allows you to do things like
+      # Resque.enqueue_at(timestamp, CustomJobClass, :opt1 => val1). Otherwise, pass off to Resque.
+      if klass.respond_to?(:scheduled)
+        klass.scheduled(queue, klass.to_s(), *args)
+      else
+        Resque::Job.create(queue, klass, *args)
+      end
     else
       delayed_push(timestamp, job_to_hash_with_queue(queue, klass, args))
     end
@@ -152,6 +180,9 @@ module ResqueScheduler
     # First add this item to the list for this timestamp
     redis.rpush("delayed:#{timestamp.to_i}", encode(item))
 
+    # Store the timestamps at with this item occurs
+    redis.sadd("timestamps:#{encode(item)}", "delayed:#{timestamp.to_i}")
+
     # Now, add this timestamp to the zsets.  The score and the value are
     # the same since we'll be querying by timestamp, and we don't have
     # anything else to store.
@@ -160,7 +191,7 @@ module ResqueScheduler
 
   # Returns an array of timestamps based on start and count
   def delayed_queue_peek(start, count)
-    Array(redis.zrange(:delayed_queue_schedule, start, start+count-1)).collect{|x| x.to_i}
+    Array(redis.zrange(:delayed_queue_schedule, start, start+count-1)).collect { |x| x.to_i }
   end
 
   # Returns the size of the delayed queue schedule
@@ -197,7 +228,9 @@ module ResqueScheduler
   def next_item_for_timestamp(timestamp)
     key = "delayed:#{timestamp.to_i}"
 
-    item = decode redis.lpop(key)
+    encoded_item = redis.lpop(key)
+    redis.srem("timestamps:#{encoded_item}", key)
+    item = decode(encoded_item)
 
     # If the list is empty, remove it.
     clean_up_timestamp(key, timestamp)
@@ -207,23 +240,36 @@ module ResqueScheduler
   # Clears all jobs created with enqueue_at or enqueue_in
   def reset_delayed_queue
     Array(redis.zrange(:delayed_queue_schedule, 0, -1)).each do |item|
-      redis.del "delayed:#{item}"
+      key = "delayed:#{item}"
+      items = redis.lrange(key, 0, -1)
+      redis.pipelined do
+        items.each { |ts_item| redis.del("timestamps:#{ts_item}") }
+      end
+      redis.del key
     end
 
     redis.del :delayed_queue_schedule
   end
 
   # Given an encoded item, remove it from the delayed_queue
-  #
-  # This method is potentially very expensive since it needs to scan
-  # through the delayed queue for every timestamp.
   def remove_delayed(klass, *args)
-    destroyed = 0
     search = encode(job_to_hash(klass, args))
-    Array(redis.keys("delayed:*")).each do |key|
-      destroyed += redis.lrem key, 0, search
+    timestamps = redis.smembers("timestamps:#{search}")
+
+    replies = redis.pipelined do
+      timestamps.each do |key|
+        redis.lrem(key, 0, search)
+        redis.srem("timestamps:#{search}", key)
+      end
     end
-    destroyed
+
+    (replies.nil? || replies.empty?) ? 0 : replies.each_slice(2).collect { |slice| slice.first }.inject(:+)
+  end
+
+  # Given an encoded item, enqueue it now
+  def enqueue_delayed(klass, *args)
+    hash = job_to_hash(klass, args)
+    remove_delayed(klass, *args).times { Resque::Scheduler.enqueue_from_config(hash) }
   end
 
   # Given a timestamp and job (klass + args) it removes all instances and
@@ -233,8 +279,12 @@ module ResqueScheduler
   # timestamp
   def remove_delayed_job_from_timestamp(timestamp, klass, *args)
     key = "delayed:#{timestamp.to_i}"
-    count = redis.lrem key, 0, encode(job_to_hash(klass, args))
+    encoded_job = encode(job_to_hash(klass, args))
+
+    redis.srem("timestamps:#{encoded_job}", key)
+    count = redis.lrem(key, 0, encoded_job)
     clean_up_timestamp(key, timestamp)
+
     count
   end
 
@@ -246,6 +296,14 @@ module ResqueScheduler
     total_jobs
   end
 
+  # Returns delayed jobs schedule timestamp for +klass+, +args+.
+  def scheduled_at(klass, *args)
+    search = encode(job_to_hash(klass, args))
+    redis.smembers("timestamps:#{search}").collect do |key|
+      key.tr('delayed:', '').to_i
+    end
+  end
+
   private
 
     def job_to_hash(klass, args)
@@ -258,6 +316,9 @@ module ResqueScheduler
 
     def clean_up_timestamp(key, timestamp)
       # If the list is empty, remove it.
+
+      # Use a watch here to ensure nobody adds jobs to this delayed
+      # queue while we're removing it.
       redis.watch key
       if 0 == redis.llen(key).to_i
         redis.multi do
@@ -268,15 +329,6 @@ module ResqueScheduler
         redis.unwatch
       end
     end
-    def validate_job!(klass)
-      if klass.to_s.empty?
-        raise Resque::NoClassError.new("Jobs must be given a class.")
-      end
-
-      unless queue_from_class(klass)
-        raise Resque::NoQueueError.new("Jobs must be placed onto a queue.")
-      end
-    end
 
     def prepare_schedule(schedule_hash)
       prepared_hash = {}
@@ -287,7 +339,6 @@ module ResqueScheduler
       end
       prepared_hash
     end
-
 end
 
 Resque.extend ResqueScheduler

data/resque-scheduler.gemspec

@@ -1,27 +1,33 @@
-# -*- encoding: utf-8 -*-
-$:.unshift File.expand_path("../lib", __FILE__)
-require "resque_scheduler/version"
+# vim:fileencoding=utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'resque_scheduler/version'
 
-Gem::Specification.new do |s|
-  s.name        = "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.
+Gem::Specification.new do |spec|
+  spec.name        = 'resque-scheduler'
+  spec.version     = ResqueScheduler::VERSION
+  spec.authors     = ['Ben VandenBos']
+  spec.email       = ['bvandenbos@gmail.com']
+  spec.homepage    = 'http://github.com/resque/resque-scheduler'
+  spec.summary     = 'Light weight job scheduling on top of Resque'
+  spec.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.}
+  spec.license = 'MIT'
 
-  s.required_rubygems_version = ">= 1.3.6"
-  s.add_development_dependency "bundler", ">= 1.0.0"
+  spec.files         = `git ls-files`.split("\n")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ['lib']
 
-  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'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'json' if RUBY_VERSION < '1.9'
+  spec.add_development_dependency 'rubocop' unless RUBY_VERSION < '1.9'
 
-  s.add_runtime_dependency(%q<redis>, [">= 2.0.1"])
-  s.add_runtime_dependency(%q<resque>, [">= 1.20.0"])
-  s.add_runtime_dependency(%q<rufus-scheduler>, [">= 0"])
+  spec.add_runtime_dependency 'redis', '>= 3.0.0'
+  spec.add_runtime_dependency 'resque', '~> 1.25'
+  spec.add_runtime_dependency 'rufus-scheduler', '~> 2.0'
 end

data/script/migrate_to_timestamps_set.rb

@@ -0,0 +1,14 @@
+require 'redis'
+require 'resque'
+
+if ARGV.size != 1
+  puts "migrate_to_timestamps_set.rb <redis-host:redis-port>"
+  exit
+end
+
+Resque.redis = ARGV[0]
+redis = Resque.redis
+Array(redis.keys("delayed:*")).each do |key|
+  jobs = redis.lrange(key, 0, -1)
+  jobs.each {|job| redis.sadd("timestamps:#{job}", key)}
+end

data/test/delayed_queue_test.rb

@@ -8,20 +8,21 @@ context "DelayedQueue" do
   end
 
   test "enqueue_at adds correct list and zset" do
-    timestamp = Time.now - 1 # 1 second ago (in the past, should come out right away)
+    timestamp = Time.now + 1
+    encoded_job =  Resque.encode(:class => SomeIvarJob.to_s, :args => ["path"], :queue => Resque.queue_from_class(SomeIvarJob))
 
     assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
+    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set 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.scard("timestamps:#{encoded_job}"), "job timestamps 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
+    read_timestamp = timestamp.to_i
 
-    # 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
@@ -31,23 +32,25 @@ context "DelayedQueue" do
     # 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")
+    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set should be empty")
   end
 
   test "enqueue_at with queue adds correct list and zset and queue" do
-    timestamp = Time.now - 1 # 1 second ago (in the past, should come out right away)
+    timestamp = Time.now + 1
+    encoded_job =  Resque.encode(:class => SomeIvarJob.to_s, :args => ["path"], :queue => 'critical')
 
     assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
+    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set 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.scard("timestamps:#{encoded_job}"), "job timestamps 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
+    read_timestamp = timestamp.to_i
 
-    # 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
@@ -58,17 +61,21 @@ context "DelayedQueue" do
     # 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")
+    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set should be empty")
   end
 
   test "a job in the future doesn't come out" do
     timestamp = Time.now + 600 # 10 minutes from now (in the future, shouldn't come out)
+    encoded_job =  Resque.encode(:class => SomeIvarJob.to_s, :args => ["path"], :queue => Resque.queue_from_class(SomeIvarJob))
 
     assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
+    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set 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.scard("timestamps:#{encoded_job}"), "job timestamps 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
@@ -88,19 +95,21 @@ context "DelayedQueue" do
 
   test "enqueue_at and enqueue_in are equivelent" do
     timestamp = Time.now + 60
+    encoded_job =  Resque.encode(:class => SomeIvarJob.to_s, :args => ["path"], :queue => Resque.queue_from_class(SomeIvarJob))
 
     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")
+    assert_equal(1, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps should have one entry now")
   end
 
   test "empty delayed_queue_peek returns empty array" do
     assert_equal([], Resque.delayed_queue_peek(0,20))
   end
 
-  test "delqyed_queue_peek returns stuff" do
+  test "delayed_queue_peek returns stuff" do
     t = Time.now
     expected_timestamps = (1..5).to_a.map do |i|
       (t + 60 + i).to_i
@@ -166,12 +175,11 @@ context "DelayedQueue" do
 
   test "handle_delayed_item with items" do
     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
+    Resque::Job.expects(:create).twice.with(:ivar, SomeIvarJob)
+    Resque.enqueue_at(t, SomeIvarJob)
+    Resque.enqueue_at(t, SomeIvarJob)
   end
 
   test "handle_delayed_items with items in the future" do
@@ -184,6 +192,24 @@ context "DelayedQueue" do
     Resque::Scheduler.handle_delayed_items(t)
   end
 
+  test "calls klass#scheduled when enqueuing jobs if it exists" do
+    t = Time.now - 60
+    FakeCustomJobClassEnqueueAt.expects(:scheduled).once.with(:test, FakeCustomJobClassEnqueueAt.to_s, {:foo => "bar"})
+    Resque.enqueue_at(t, FakeCustomJobClassEnqueueAt, :foo => "bar")
+  end
+
+  test "when Resque.inline = true, calls klass#scheduled when enqueuing jobs if it exists" do
+    old_val = Resque.inline
+    begin
+      Resque.inline = true
+      t = Time.now - 60
+      FakeCustomJobClassEnqueueAt.expects(:scheduled).once.with(:test, FakeCustomJobClassEnqueueAt.to_s, {:foo => "bar"})
+      Resque.enqueue_at(t, FakeCustomJobClassEnqueueAt, :foo => "bar")
+    ensure
+      Resque.inline = old_val
+    end
+  end
+
   test "enqueue_delayed_items_for_timestamp creates jobs and empties the delayed queue" do
     t = Time.now + 60
 
@@ -199,6 +225,24 @@ context "DelayedQueue" do
     assert_equal(0, Resque.delayed_timestamp_peek(t, 0, 3).length)
   end
 
+  test "enqueue_delayed creates jobs and empties the delayed queue" do
+    t = Time.now + 60
+
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    Resque.enqueue_at(t, SomeIvarJob, "bar")
+    Resque.enqueue_at(t, SomeIvarJob, "bar")
+
+    # 3 SomeIvarJob jobs should be created in the "ivar" queue
+    Resque::Job.expects(:create).never.with(:ivar, SomeIvarJob, "foo")
+    Resque::Job.expects(:create).twice.with(:ivar, SomeIvarJob, "bar")
+
+    # 2 SomeIvarJob jobs should be enqueued
+    assert_equal(2, Resque.enqueue_delayed(SomeIvarJob, "bar"))
+
+    # delayed queue for timestamp should have one remaining
+    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 3).length)
+  end
+
   test "handle_delayed_items works with out specifying queue (upgrade case)" do
     t = Time.now - 60
     Resque.delayed_push(t, :class => 'SomeIvarJob')
@@ -218,13 +262,23 @@ context "DelayedQueue" do
 
     Resque.reset_delayed_queue
     assert_equal(0, Resque.delayed_queue_schedule_size)
+    assert_equal(0, Resque.redis.keys("timestamps:*").size)
   end
 
   test "remove_delayed removes job and returns the count" do
     t = Time.now + 120
+    encoded_job =  Resque.encode(:class => SomeIvarJob.to_s, :args => [], :queue => Resque.queue_from_class(SomeIvarJob))
     Resque.enqueue_at(t, SomeIvarJob)
 
     assert_equal(1, Resque.remove_delayed(SomeIvarJob))
+    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"))
+  end
+
+  test "scheduled_at returns an array containing job schedule time" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob)
+
+    assert_equal([t.to_i], Resque.scheduled_at(SomeIvarJob))
   end
 
   test "remove_delayed doesn't remove things it shouldn't" do
@@ -304,9 +358,6 @@ context "DelayedQueue" do
   end
 
   test "invalid job class" do
-    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

data/test/redis-test.conf

@@ -106,10 +106,3 @@ databases 16
 # errors for write operations, and this may even lead to DB inconsistency.
 
 # maxmemory <bytes>
-
-############################### ADVANCED CONFIG ###############################
-
-# Glue small output buffers together in order to send small replies in a
-# single TCP packet. Uses a bit more CPU but most of the times it is a win
-# in terms of number of queries per second. Use 'yes' if unsure.
-glueoutputbuf yes

data/test/resque-web_test.rb

@@ -10,10 +10,24 @@ context "on GET to /schedule" do
 end
 
 context "on GET to /schedule with scheduled jobs" do
-  setup do 
+  setup do
     ENV['rails_env'] = 'production'
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'},
-                       :some_other_job => {'queue' => 'high', 'class' => 'SomeOtherJob', 'args' => {:b => 'blah'}}}
+    Resque.schedule = {
+      'some_ivar_job' => {
+        'cron' => "* * * * *",
+        'class' => 'SomeIvarJob',
+        'args' => "/tmp",
+        'rails_env' => 'production'
+      },
+      'some_other_job' => {
+        'every' => ['5m'],
+        'queue' => 'high',
+        'class' => 'SomeOtherJob',
+        'args' => {
+          'b' => 'blah'
+        }
+      }
+    }
     Resque::Scheduler.load_schedule!
     get "/schedule"
   end
@@ -30,3 +44,91 @@ context "on GET to /delayed" do
 
   should_respond_with_success
 end
+
+def resque_schedule
+  {
+    'job_without_params' => {
+      'cron' => '* * * * *',
+      'class' => 'JobWithoutParams',
+      'args' => {
+        'host' => 'localhost'
+      },
+      'rails_env' => 'production'},
+    'job_with_params' => {
+      'cron' => '* * * * *',
+      'class' => 'JobWithParams',
+      'args' => {
+        'host' => 'localhost'
+      },
+      'parameters' => {
+        'log_level' => {
+          'description' => 'The level of logging',
+          'default' => 'warn'
+        }
+      }
+    }
+  }
+end
+
+context "POST /schedule/requeue" do
+  setup do
+    Resque.schedule = resque_schedule
+    Resque::Scheduler.load_schedule!
+  end
+
+  test 'job without params' do
+    # Regular jobs without params should redirect to /overview
+    job_name = 'job_without_params'
+    Resque::Scheduler.stubs(:enqueue_from_config).once.with(Resque.schedule[job_name])
+
+    post '/schedule/requeue', {'job_name' => job_name}
+    follow_redirect!
+    assert_equal "http://example.org/overview", last_request.url
+    assert last_response.ok?
+  end
+
+  test 'job with params' do
+    # If a job has params defined,
+    # it should render the template with a form for the job params
+    job_name = 'job_with_params'
+    post '/schedule/requeue', {'job_name' => job_name}
+
+    assert last_response.ok?, last_response.errors
+    assert last_response.body.include?("This job requires parameters")
+    assert last_response.body.include?("<input type=\"hidden\" name=\"job_name\" value=\"#{job_name}\">")
+
+    Resque.schedule[job_name]['parameters'].each do |param_name, param_config|
+      assert last_response.body.include?(
+        "<span style=\"border-bottom:1px dotted;\" title=\"#{param_config['description']}\">(?)</span>")
+      assert last_response.body.include?(
+        "<input type=\"text\" name=\"log_level\" value=\"#{param_config['default']}\">")
+    end
+  end
+end
+
+context "POST /schedule/requeue_with_params" do
+  setup do
+    Resque.schedule = resque_schedule
+    Resque::Scheduler.load_schedule!
+  end
+
+  test 'job with params' do
+    job_name = 'job_with_params'
+    log_level = 'error'
+
+    job_config = Resque.schedule[job_name]
+    args = job_config['args'].merge('log_level' => log_level)
+    job_config = job_config.merge('args' => args)
+
+    Resque::Scheduler.stubs(:enqueue_from_config).once.with(job_config)
+
+    post '/schedule/requeue_with_params', {
+      'job_name' => job_name,
+      'log_level' => log_level
+    }
+    follow_redirect!
+    assert_equal "http://example.org/overview", last_request.url
+
+    assert last_response.ok?, last_response.errors
+  end
+end

data/test/scheduler_args_test.rb

@@ -77,7 +77,7 @@ context "scheduling jobs with arguments" do
   test "calls the worker without arguments when 'args' is blank in the config" do
     Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
       class: SomeIvarJob
-      args: 
+      args:
     YAML
     SomeIvarJob.expects(:perform).once.with()
     Resque.reserve('ivar').perform