resque-mongo-scheduler 2.0.2

data/lib/resque_scheduler.rb

@@ -0,0 +1,238 @@
+require 'rubygems'
+gem 'resque-mongo'
+require 'resque'
+require 'resque/server'
+require 'resque_scheduler/version'
+require 'resque/scheduler'
+require 'resque_scheduler/server'
+require 'resque_scheduler/search_delayed'
+
+module ResqueScheduler
+
+  def schedules
+    self.mongo ||= ENV['MONGO'] || 'localhost:27017'
+    @schedules ||= @db.collection('schedules')
+  end
+
+  def schedules_changed
+    self.mongo ||= ENV['MONGO'] || 'localhost:27017'
+    @schedules_changed ||= @db.collection('schedules_changed')
+  end
+
+  def delayed_queue
+    self.mongo ||= ENV['MONGO'] || 'localhost:27017'
+    @delayed_queue ||= @db.collection('delayed_queue')
+  end
+
+  #
+  # Accepts a new schedule configuration of the form:
+  #
+  #   {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
+  # :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)
+  # :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|
+        set_schedule(name, job_spec)
+      end
+    end
+    @schedule = schedule_hash
+  end
+
+  # Returns the schedule hash
+  def schedule
+    @schedule ||= {}
+  end
+  
+  # reloads the schedule from mongo
+  def reload_schedule!
+    @schedule = get_schedules
+  end
+  
+  # gets the schedule as it exists in mongo
+  def get_schedules
+    if schedules.count > 0
+      h = {}
+      schedules.find.each do |a|
+        h[a.delete('_id')] = a
+      end
+      h
+    else
+      nil
+    end
+  end
+  
+  # create or update a schedule with the provided name and configuration
+  def set_schedule(name, config)
+    existing_config = get_schedule(name)
+    unless existing_config && existing_config == config
+      schedules.insert(config.merge('_id' => name))
+      schedules_changed.insert('_id' => name)
+    end
+    config
+  end
+  
+  # retrieve the schedule configuration for the given name
+  def get_schedule(name)
+    schedule = schedules.find_one('_id' => name)
+    schedule.delete('_id') if schedule
+    schedule
+  end
+  
+  # remove a given schedule by name
+  def remove_schedule(name)
+    schedules.remove('_id' => name)
+    schedules_changed.insert('_id' => name)
+  end
+
+  def pop_schedules_changed
+    while doc = schedules_changed.find_and_modify(:remove => true)
+      yield doc['_id']
+    end
+  rescue Mongo::OperationFailure
+    # "Database command 'findandmodify' failed: {"errmsg"=>"No matching object found", "ok"=>0.0}"
+    # Sadly, the mongo driver raises (with a global exception class) instead of returning nil when
+    # the collection is empty.
+  end
+
+  # This method is nearly identical to +enqueue+ only it also
+  # takes a timestamp which will be used to schedule the job
+  # for queueing.  Until timestamp is in the past, the job will
+  # sit in the schedule list.
+  # @return the number of items for this timestamp
+  def enqueue_at(timestamp, klass, *args)
+    delayed_push(timestamp, job_to_hash(klass, args))
+  end
+
+  # Identical to enqueue_at but takes number_of_seconds_from_now
+  # instead of a timestamp.
+  # @return the number of items for this timestamp
+  def enqueue_in(number_of_seconds_from_now, klass, *args)
+    enqueue_at(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)).
+  # Returns true if it's the first job to be scheduled at that time, else false
+  # @return the number of items for this timestamp
+  def delayed_push(timestamp, item)
+    # Add this item to the list for this timestamp
+    doc = delayed_queue.find_and_modify(
+      :query => {'_id' => timestamp.to_i},
+      :update => {'$push' => {:items => item}},
+      :upsert => true,
+      :new => true
+    )
+    doc['items'].size
+  end
+
+  # Returns an array of timestamps based on start and count
+  def delayed_queue_peek(start, count)
+    delayed_queue.find({}, :skip => start, :limit => count, :fields => '_id', :sort => ['_id', 1]).map {|d| d['_id']}
+  end
+
+  # Returns the size of the delayed queue schedule
+  def delayed_queue_schedule_size
+    delayed_queue.count
+  end
+
+  # Returns the number of jobs for a given timestamp in the delayed queue schedule
+  def delayed_timestamp_size(timestamp)
+    document = delayed_queue.find_one('_id' => timestamp.to_i)
+    document ? (document['items'] || []).size : 0
+  end
+
+  # Returns an array of delayed items for the given timestamp
+  def delayed_timestamp_peek(timestamp, start, count)
+    doc = delayed_queue.find_one(
+      {'_id' => timestamp.to_i},
+      :fields => {'items' => {'$slice' => [start, count]}}
+    )
+    doc ? doc['items'] || [] : []
+  end
+
+  # Returns the next delayed queue timestamp
+  # (don't call directly)
+  def next_delayed_timestamp(at_time=nil)
+    doc = delayed_queue.find_one(
+      {'_id' => {'$lte' => (at_time || Time.now).to_i}},
+      :sort => ['_id', Mongo::ASCENDING]
+    )
+    doc ? doc['_id'] : nil
+  end
+
+  # Returns the next item to be processed for a given timestamp, nil if
+  # done. (don't call directly)
+  # +timestamp+ can either be in seconds or a datetime
+  def next_item_for_timestamp(timestamp)
+    # Returns the array of items before it was shifted
+    doc = delayed_queue.find_and_modify(
+      :query => {'_id' => timestamp.to_i},
+      :update => {'$pop' => {'items' => -1}} # -1 means shift
+    )
+    item = doc['items'].first
+    
+    # If the list is empty, remove it.
+    clean_up_timestamp(timestamp)
+    
+    item
+  rescue Mongo::OperationFailure
+    # Database command 'findandmodify' failed: {"errmsg"=>"No matching object found", "ok"=>0.0}
+    nil
+  end
+
+  # Clears all jobs created with enqueue_at or enqueue_in
+  def reset_delayed_queue
+    delayed_queue.remove
+  end
+
+  # given an encoded item, remove it from the delayed_queue
+  # does not clean like +next_item_for_timestamp+
+  # TODO ? unlike resque-scheduler, it does not return the number of removed items,
+  # can't use find_and_modify because it only updates one item.
+  def remove_delayed(klass, *args)
+    delayed_queue.update(
+      {},
+      {'$pull' => {'items' => job_to_hash(klass, args)}},
+      :multi => true
+    )
+  end
+
+  def count_all_scheduled_jobs
+    total_jobs = 0
+    delayed_queue.find.each do |doc|
+      total_jobs += (doc['items'] || []).size
+    end
+    total_jobs
+  end 
+
+  private
+    def job_to_hash(klass, args)
+      {:class => klass.to_s, :args => args, :queue => queue_from_class(klass).to_s}
+    end
+
+    def clean_up_timestamp(timestamp)
+      delayed_queue.remove('_id' => timestamp.to_i, :items => {'$size' => 0})
+    end
+
+end
+
+Resque.extend ResqueScheduler
+Resque::Server.class_eval do
+  include ResqueScheduler::Server
+end

data/resque-mongo-scheduler.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/resque_scheduler/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "resque-mongo-scheduler"
+  s.version     = ResqueScheduler::Version
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Ben VandenBos', 'Nicolas Fouché']
+  s.email       = ['bvandenbos@gmail.com', 'nicolas@silentale.com']
+  s.homepage    = "http://github.com/nfo/resque-mongo-scheduler"
+  s.summary     = "Light weight job scheduling on top of Resque Mongo"
+  s.description = %q{Light weight job scheduling on top of Resque Mongo.
+    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<mongo>, [">= 1.1"])
+  s.add_runtime_dependency(%q<resque-mongo>, [">= 1.11.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,234 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Resque::DelayedQueueTest < Test::Unit::TestCase
+
+  def setup
+    Resque::Scheduler.mute = true
+    Resque.flushall
+  end
+
+  def test_enqueue_at_adds_correct_list
+
+    timestamp = Time.now - 1 # 1 second ago (in the past, should come out right away)
+
+    assert_equal(0, Resque.delayed_queue.count, "delayed queue should be empty to start")
+
+    assert_equal 1, Resque.enqueue_at(timestamp, SomeIvarJob, "path")
+
+    # Confirm the correct keys were added
+    assert_equal(1, Resque.delayed_queue.find_one('_id' => timestamp.to_i)['items'].size, "delayed queue should have one entry now")
+    assert_equal(1, Resque.delayed_queue_schedule_size, "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_equal(0, Resque.delayed_queue.find('_id' => timestamp.to_i).count) # tests +clean_up_timestamp+
+    assert_equal(0, Resque.delayed_queue_schedule_size, "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.delayed_queue.find('_id' => timestamp.to_i).count, "delayed queue should be empty to start")
+
+    assert_equal 1, Resque.enqueue_at(timestamp, SomeIvarJob, "path")
+
+    # Confirm the correct keys were added
+    assert_equal(1, Resque.delayed_queue.find_one('_id' => timestamp.to_i)['items'].size, "delayed queue should have one entry now")
+    assert_equal(1, Resque.delayed_queue_schedule_size, "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
+
+    assert_equal 1, 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_equivalent
+    timestamp = Time.now + 60
+
+    assert_equal 1, Resque.enqueue_at(timestamp, SomeIvarJob, "path")
+    assert_equal 2, Resque.enqueue_in(timestamp - Time.now, SomeIvarJob, "path")
+
+    assert_equal(1, Resque.delayed_queue_schedule_size, "should have one timestamp in the delayed queue")
+    assert_equal(2, Resque.delayed_queue.find_one('_id' => timestamp.to_i)['items'].size, "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.to_s, :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)
+    assert_equal 1, 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))
+    assert_equal 1, 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")
+    assert_equal 1, Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 1).length)
+    assert_equal 2, 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
+    assert_equal 1, Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal 2, 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
+  end
+
+  def test_handle_delayed_items_with_items_in_the_future
+    t = Time.now + 60 # in the future
+    assert_equal 1, Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal 2, 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
+    
+    assert_equal 1, Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal 2, 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.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 { |i| assert_equal i + 1, Resque.enqueue_at(t, SomeIvarJob) }
+    4.times { |i| assert_equal 1, 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
+    assert_equal 1, Resque.enqueue_at(t, SomeIvarJob)
+
+    Resque.remove_delayed(SomeIvarJob)
+    assert_equal [], Resque.delayed_queue.find_one('_id' => t.to_i)['items']
+  end
+
+  def test_remove_bogus_item_leaves_the_rest_alone
+    t = Time.now + 120
+    assert_equal 1, Resque.enqueue_at(t, SomeIvarJob, "foo")
+    assert_equal 2, Resque.enqueue_at(t, SomeIvarJob, "bar")
+    assert_equal 3, Resque.enqueue_at(t, SomeIvarJob, "bar")
+    assert_equal 4, Resque.enqueue_at(t, SomeIvarJob, "baz")
+
+    Resque.remove_delayed(SomeIvarJob)
+    
+    items = Resque.delayed_queue.find_one('_id' => t.to_i)['items']
+    assert_equal(4, items.size)
+  end
+
+  def test_remove_specific_item_in_group_of_other_items_at_same_timestamp
+    t = Time.now + 120
+    assert_equal 1, Resque.enqueue_at(t, SomeIvarJob, "foo")
+    assert_equal 2, Resque.enqueue_at(t, SomeIvarJob, "bar")
+    assert_equal 3, Resque.enqueue_at(t, SomeIvarJob, "bar")
+    assert_equal 4, Resque.enqueue_at(t, SomeIvarJob, "baz")
+
+    Resque.remove_delayed(SomeIvarJob, "bar")
+    
+    items = Resque.delayed_queue.find_one('_id' => t.to_i)['items']
+    assert_equal(2, items.size)
+    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
+    assert_equal 1, Resque.enqueue_at(t, SomeIvarJob, "foo")
+    assert_equal 1, Resque.enqueue_at(t + 1, SomeIvarJob, "bar")
+    assert_equal 1, Resque.enqueue_at(t + 2, SomeIvarJob, "bar")
+    assert_equal 1, Resque.enqueue_at(t + 3, SomeIvarJob, "baz")
+
+    Resque.remove_delayed(SomeIvarJob, "bar")
+    assert_equal(1, Resque.delayed_queue.find_one('_id' => t.to_i)['items'].size)
+    assert_equal(0, Resque.delayed_queue.find_one('_id' => t.to_i + 1)['items'].size)
+    assert_equal(0, Resque.delayed_queue.find_one('_id' => t.to_i + 2)['items'].size)
+    assert_equal(1, Resque.delayed_queue.find_one('_id' => t.to_i + 3)['items'].size)
+    assert_equal(2, Resque.count_all_scheduled_jobs)
+  end
+end

data/test/redis-test.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9736
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# 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

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Pull in the server test_helper from resque
+require 'resque/server/test_helper.rb'
+
+context "on GET to /schedule" do
+  setup { get "/schedule" }
+
+  should_respond_with_success
+end
+
+context "on GET to /schedule with scheduled jobs" do
+  setup do 
+    ENV['rails_env'] = 'production'
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'}}
+    Resque::Scheduler.load_schedule!
+    get "/schedule"
+  end
+
+  should_respond_with_success
+
+  test 'see the scheduled job' do
+    assert last_response.body.include?('SomeIvarJob')
+  end
+end
+
+context "on GET to /delayed" do
+  setup { get "/delayed" }
+
+  should_respond_with_success
+end