sskirby-resque-scheduler 1.10.8

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,35 @@
+<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>Cron</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="<%= url "/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"><%= h 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>
+    </tr>
+  <% end %>
+</table>

data/lib/resque_scheduler/server.rb

@@ -0,0 +1,58 @@
+
+# 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")
+          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 url("/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 url("/overview")
+        end
+
+      end
+
+    end
+
+    Resque::Server.tabs << 'Schedule'
+    Resque::Server.tabs << 'Delayed'
+
+  end
+  
+end

data/lib/resque_scheduler/tasks.rb

@@ -0,0 +1,24 @@
+# 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'
+
+    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 = '1.10.8'
+end

data/lib/resque_scheduler.rb

@@ -0,0 +1,189 @@
+require 'rubygems'
+require 'resque'
+require 'resque/server'
+require 'resque_scheduler/version'
+require 'resque/scheduler'
+require 'resque_scheduler/server'
+
+module ResqueScheduler
+
+  #
+  # 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
+  # :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)
+    @schedule = schedule_hash
+  end
+
+  # Returns the schedule hash
+  def schedule
+    @schedule ||= {}
+  end
+  
+  # reloads the schedule from redis
+  def reload_schedule!
+    @schedule = get_schedules
+  end
+  
+  # gets the schedule as it exists in redis
+  def get_schedules
+    if redis.exists(:schedules)
+      redis.hgetall(:schedules).tap do |h|
+        h.each do |name, config|
+          h[name] = decode(config)
+        end
+      end
+    else
+      nil
+    end
+  end
+  
+  # create or update a schedule with the provided name and configuration
+  def set_schedule(name, config)
+    redis.hset(:schedules, name, encode(config))
+  end
+  
+  # retrive the schedule configuration for the given name
+  def get_schedule(name)
+    decode(redis.hget(:schedules, name))
+  end
+  
+  # remove a given schedule by name
+  def remove_schedule(name)
+    redis.hdel(:schedules, name)
+  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.
+  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.
+  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
+  def delayed_push(timestamp, item)
+    # First add this item to the list for this timestamp
+    redis.rpush("delayed:#{timestamp.to_i}", encode(item))
+
+    # 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.
+    redis.zadd :delayed_queue_schedule, timestamp.to_i, timestamp.to_i
+  end
+
+  # 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)).collect{|x| x.to_i}
+  end
+
+  # Returns the size of the delayed queue schedule
+  def delayed_queue_schedule_size
+    redis.zcard :delayed_queue_schedule
+  end
+
+  # Returns the number of jobs for a given timestamp in the delayed queue schedule
+  def delayed_timestamp_size(timestamp)
+    redis.llen("delayed:#{timestamp.to_i}").to_i
+  end
+
+  # Returns an array of delayed items for the given timestamp
+  def delayed_timestamp_peek(timestamp, start, count)
+    if 1 == count
+      r = list_range "delayed:#{timestamp.to_i}", start, count
+      r.nil? ? [] : [r]
+    else
+      list_range "delayed:#{timestamp.to_i}", start, count
+    end
+  end
+
+  # 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]
+    timestamp = items.nil? ? nil : Array(items).first
+    timestamp.to_i unless timestamp.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)
+    key = "delayed:#{timestamp.to_i}"
+
+    item = decode redis.lpop(key)
+
+    # If the list is empty, remove it.
+    clean_up_timestamp(key, timestamp)
+    item
+  end
+
+  # 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}"
+    end
+
+    redis.del :delayed_queue_schedule
+  end
+
+  # given an encoded item, remove it from the delayed_queue
+  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
+    end
+    destroyed
+  end
+
+  def count_all_scheduled_jobs
+    total_jobs = 0 
+    Array(redis.zrange(:delayed_queue_schedule, 0, -1)).each do |timestamp|
+      total_jobs += redis.llen("delayed:#{timestamp}").to_i
+    end 
+    total_jobs
+  end 
+
+  private
+    def job_to_hash(klass, args)
+      {:class => klass.to_s, :args => args, :queue => queue_from_class(klass)}
+    end
+
+    def clean_up_timestamp(key, timestamp)
+      # If the list is empty, remove it.
+      if 0 == redis.llen(key).to_i
+        redis.del key
+        redis.zrem :delayed_queue_schedule, timestamp.to_i
+      end
+    end
+
+end
+
+Resque.extend ResqueScheduler
+Resque::Server.class_eval do
+  include ResqueScheduler::Server
+end

data/sskirby-resque-scheduler.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sskirby-resque-scheduler}
+  s.version = "1.10.8"
+
+  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-10-26}
+  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.email = %q{sskirby@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "HISTORY.md",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "lib/resque/scheduler.rb",
+     "lib/resque_scheduler.rb",
+     "lib/resque_scheduler/server.rb",
+     "lib/resque_scheduler/server/views/delayed.erb",
+     "lib/resque_scheduler/server/views/delayed_timestamp.erb",
+     "lib/resque_scheduler/server/views/scheduler.erb",
+     "lib/resque_scheduler/tasks.rb",
+     "lib/resque_scheduler/version.rb",
+     "sskirby-resque-scheduler.gemspec",
+     "tasks/resque_scheduler.rake",
+     "test/delayed_queue_test.rb",
+     "test/redis-test.conf",
+     "test/resque-web_test.rb",
+     "test/scheduler_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/sskirby/resque-scheduler}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Light weight job scheduling on top of Resque}
+  s.test_files = [
+    "test/scheduler_test.rb",
+     "test/test_helper.rb",
+     "test/resque-web_test.rb",
+     "test/delayed_queue_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, [">= 2.0.1"])
+      s.add_runtime_dependency(%q<resque>, [">= 1.8.0"])
+      s.add_runtime_dependency(%q<rufus-scheduler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<rack-test>, [">= 0"])
+    else
+      s.add_dependency(%q<redis>, [">= 2.0.1"])
+      s.add_dependency(%q<resque>, [">= 1.8.0"])
+      s.add_dependency(%q<rufus-scheduler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<rack-test>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<redis>, [">= 2.0.1"])
+    s.add_dependency(%q<resque>, [">= 1.8.0"])
+    s.add_dependency(%q<rufus-scheduler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<rack-test>, [">= 0"])
+  end
+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,199 @@
+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_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_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.expects(:queue_from_class).never # Should NOT need to load the class
+    Resque::Scheduler.handle_delayed_items
+  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::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
+end