nulogy-resque-scheduler 1.10.15

data/lib/resque_scheduler.rb

@@ -0,0 +1,202 @@
+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
+  # :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 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)
+    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
+  def get_schedule(name)
+    decode(redis.hget(:schedules, name))
+  end
+  
+  # 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
+  # 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(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
+
+  # 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/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/server/views/delayed.erb

@@ -0,0 +1,42 @@
+<h1>Delayed Jobs</h1>
+
+<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 = resque.delayed_queue_schedule_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, start+20).each do |timestamp| %>
+    <tr>
+      <td>
+        <form action="<%= url "/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="<%= url "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="<%= url "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,37 @@
+<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="<%= 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"><%= (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>
+    </tr>
+  <% end %>
+</table>

data/lib/resque_scheduler/tasks.rb

@@ -0,0 +1,33 @@
+# 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']
+    if File.exists?("config/airbrake.yml")
+      Resque::Scheduler.airbrake = true 
+      Airbrake::configure do |config|
+        yaml = YAML.load_file("config/airbrake.yml")
+        yaml.each do |key, val|
+          config.send(:"#{key}=", val)
+        end
+      end
+    end
+    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.15'
+end

data/nulogy-resque-scheduler.gemspec

@@ -0,0 +1,86 @@
+# 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{nulogy-resque-scheduler}
+  s.version = "1.10.15"
+
+  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", "Justin Fitzsimmons"]
+  s.date = %q{2011-09-23}
+  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<tanzeeb-rufus-scheduler>, [">= 0"])
+      s.add_runtime_dependency(%q<airbrake>, [">= 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<tanzeeb-rufus-scheduler>, [">= 0"])
+      s.add_dependency(%q<airbrake>, [">= 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<tanzeeb-rufus-scheduler>, [">= 0"])
+    s.add_dependency(%q<airbrake>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<rack-test>, [">= 0"])
+  end
+end
+