resque-mongo-scheduler 2.0.2

data/lib/resque/scheduler.rb

@@ -0,0 +1,244 @@
+require 'rufus/scheduler'
+require 'thwait'
+
+module Resque
+
+  class Scheduler
+
+    extend Resque::Helpers
+
+    class << self
+
+      # If true, logs more stuff...
+      attr_accessor :verbose
+      
+      # If set, produces no output
+      attr_accessor :mute
+      
+      # If set, will try to update the schulde in the loop
+      attr_accessor :dynamic
+      
+      # the Rufus::Scheduler jobs that are scheduled
+      def scheduled_jobs
+        @@scheduled_jobs
+      end
+
+      # Schedule all jobs and continually look for delayed jobs (never returns)
+      def run
+        $0 = "resque-mongo-scheduler: Starting"
+        # trap signals
+        register_signal_handlers
+
+        # Load the schedule into rufus
+        procline "Loading Schedule"
+        load_schedule!
+
+        # Now start the scheduling part of the loop.
+        loop do
+          handle_delayed_items
+          update_schedule if dynamic
+          poll_sleep
+        end
+
+        # never gets here.
+      end
+
+      # For all signals, set the shutdown flag and wait for current
+      # poll/enqueing to finish (should be almost istant).  In the
+      # case of sleeping, exit immediately.
+      def register_signal_handlers
+        trap("TERM") { shutdown }
+        trap("INT") { shutdown }
+        
+        begin
+          trap('QUIT') { shutdown   }
+          trap('USR1') { kill_child }
+          trap('USR2') { reload_schedule! }
+        rescue ArgumentError
+          warn "Signals QUIT and USR1 and USR2 not supported."
+        end
+      end
+
+      # Pulls the schedule from Resque.schedule and loads it into the
+      # rufus scheduler instance
+      def load_schedule!
+        log! "Schedule empty! Set Resque.schedule" if Resque.schedule.empty?
+        
+        @@scheduled_jobs = {}
+        
+        Resque.schedule.each do |name, config|
+          load_schedule_job(name, config)
+        end
+        Resque.schedules_changed.remove
+        procline "Schedules Loaded"
+      end
+      
+      # Loads a job schedule into the Rufus::Scheduler and stores it in @@scheduled_jobs
+      def load_schedule_job(name, config)
+        # If rails_env is set in the config, enforce ENV['RAILS_ENV'] as
+        # required for the jobs to be scheduled.  If rails_env is missing, the
+        # job should be scheduled regardless of what ENV['RAILS_ENV'] is set
+        # to.
+        if config['rails_env'].nil? || rails_env_matches?(config)
+          log! "Scheduling #{name} "
+          interval_defined = false
+          interval_types = %w{cron every}
+          interval_types.each do |interval_type|
+            if !config[interval_type].nil? && config[interval_type].length > 0
+              begin
+                @@scheduled_jobs[name] = rufus_scheduler.send(interval_type, config[interval_type]) do
+                  log! "queueing #{config['class']} (#{name})"
+                  enqueue_from_config(config)
+                end
+              rescue Exception => e
+                log! "#{e.class.name}: #{e.message}"
+              end
+              interval_defined = true
+              break
+            end
+          end
+          unless interval_defined
+            log! "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
+          end
+        end
+      end
+
+      # Returns true if the given schedule config hash matches the current
+      # ENV['RAILS_ENV']
+      def rails_env_matches?(config)
+        config['rails_env'] && ENV['RAILS_ENV'] && config['rails_env'].gsub(/\s/,'').split(',').include?(ENV['RAILS_ENV'])
+      end
+
+      # Handles queueing delayed items
+      # at_time - Time to start scheduling items (default: now).
+      def handle_delayed_items(at_time=nil)
+        item = nil
+        if timestamp = Resque.next_delayed_timestamp(at_time)
+          procline "Processing Delayed Items"
+          while !timestamp.nil?
+            enqueue_delayed_items_for_timestamp(timestamp)
+            timestamp = Resque.next_delayed_timestamp(at_time)
+          end
+        end
+      end
+      
+      # Enqueues all delayed jobs for a timestamp
+      def enqueue_delayed_items_for_timestamp(timestamp)
+        item = nil
+        begin
+          handle_shutdown do
+            if item = Resque.next_item_for_timestamp(timestamp)
+              log "queuing #{item['class']} [delayed]"
+              queue = item['queue'] || Resque.queue_from_class(constantize(item['class']))
+              # Support custom job classes like job with status
+              if (job_klass = item['custom_job_class']) && (job_klass != 'Resque::Job')
+                # custom job classes not supporting the same API calls must implement the #schedule method
+                constantize(job_klass).scheduled(queue, item['class'], *item['args'])
+              else
+                klass, args = item['class'], item['args']
+                Resque.enqueue(constantize(klass), *args)
+              end
+            end
+          end
+        # continue processing until there are no more ready items in this timestamp
+        end while !item.nil?
+      end
+
+      def handle_shutdown
+        exit if @shutdown
+        yield
+        exit if @shutdown
+      end
+
+      # Enqueues a job based on a config hash
+      def enqueue_from_config(config)
+        args = config['args'] || config[:args]
+        klass_name = config['class'] || config[:class]
+        params = args.is_a?(Hash) ? [args] : Array(args)
+        queue = config['queue'] || config[:queue] || Resque.queue_from_class(constantize(klass_name))
+        # Support custom job classes like job with status
+        if (job_klass = config['custom_job_class']) && (job_klass != 'Resque::Job')
+          # custom job classes not supporting the same API calls must implement the #schedule method
+          constantize(job_klass).scheduled(queue, klass_name, *params)
+        else
+          Resque.enqueue(constantize(klass_name), *params)
+        end        
+      end
+
+      def rufus_scheduler
+        @rufus_scheduler ||= Rufus::Scheduler.start_new
+      end
+
+      # Stops old rufus scheduler and creates a new one.  Returns the new
+      # rufus scheduler
+      def clear_schedule!
+        rufus_scheduler.stop
+        @rufus_scheduler = nil
+        @@scheduled_jobs = {}
+        rufus_scheduler
+      end
+      
+      def reload_schedule!
+        procline "Reloading Schedule"
+        clear_schedule!
+        Resque.reload_schedule!
+        load_schedule!
+      end
+      
+      def update_schedule
+        if Resque.schedules_changed.count > 0
+          procline "Updating schedule"
+          Resque.reload_schedule!
+          Resque.pop_schedules_changed do |schedule_name|
+            if Resque.schedule.keys.include?(schedule_name)
+              unschedule_job(schedule_name)
+              load_schedule_job(schedule_name, Resque.schedule[schedule_name])
+            else
+              unschedule_job(schedule_name)
+            end
+          end
+          procline "Schedules Loaded"
+        end
+      end
+      
+      def unschedule_job(name)
+        if scheduled_jobs[name]
+          log "Removing schedule #{name}"
+          scheduled_jobs[name].unschedule
+          @@scheduled_jobs.delete(name)
+        end
+      end
+
+      # Sleeps and returns true
+      def poll_sleep
+        @sleeping = true
+        handle_shutdown { sleep 5 }
+        @sleeping = false
+        true
+      end
+
+      # Sets the shutdown flag, exits if sleeping
+      def shutdown
+        @shutdown = true
+        exit if @sleeping
+      end
+
+      def log!(msg)
+        puts "#{Time.now.strftime("%Y-%m-%d %H:%M:%S")} #{msg}" unless mute
+      end
+
+      def log(msg)
+        # add "verbose" logic later
+        log!(msg) if verbose
+      end
+      
+      def procline(string)
+        $0 = "resque-mongo-scheduler-#{ResqueScheduler::Version}: #{string}"
+        log! $0
+      end
+
+    end
+
+  end
+
+end

data/lib/resque_scheduler/search_delayed.rb

@@ -0,0 +1,49 @@
+module ResqueScheduler
+  
+  def search_delayed_count
+    @@search_results.count
+  end
+  
+  def search_delayed(query, start = 0, count = 1)
+    if query.nil? || query.empty?
+      @@search_results = []
+      return []
+    end
+  
+    start, count = [start, count].map { |n| Integer(n) }
+    set_results = Set.new
+
+    # For each search term, retrieve the failed jobs that contain at least one relevant field matching the regexp defined by that search term
+    query.split.each do |term|
+      
+      partial_results = []
+      self.delayed_queue.find().each do |row|
+        row['items'].each do |job|
+          if job['class'] =~ /#{term}/i || job['queue'] =~ /#{term}/i
+            partial_results << row['_id']
+          else
+            job['args'].each do |arg|
+              arg.each do |key, value|
+                if key =~ /#{term}/i || value =~ /#{term}/i
+                  partial_results << row['_id']
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # If the set was empty, merge the first results, else intersect it with the current results
+      if set_results.empty?
+        set_results.merge(partial_results)
+      else
+        set_results = set_results & partial_results
+      end
+    end
+      
+    # search_res will be an array containing 'count' values, starting with 'start', sorted in descending order
+    @@search_results = set_results.to_a || []
+    search_results = set_results.to_a[start, count]
+    search_results || []
+  end
+end

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

@@ -0,0 +1,64 @@
+<%start = params[:start].to_i %>
+<%count = params[:count] ? params[:count].to_i : 50 %>
+
+<%if params[:q].nil?%>
+<% delayed = [resque.delayed_queue_peek(start, start + 20)].flatten %>
+<% size = resque.delayed_queue_schedule_size %>
+<h1>Delayed Jobs</h1>
+<%else%>
+<% delayed = [resque.search_delayed(params[:q], start, count)].flatten %>
+<% size = resque.search_delayed_count %>
+<h1>Delayed jobs search results</h1>
+<%end%>
+
+<p class='intro'>
+  This list below contains the timestamps for scheduled delayed jobs.
+</p>
+
+<% unless size.zero? %>
+<form method="GET" action="<%=u 'delayed'%>">
+  <input type='text' name='q'>
+  <input type='submit' name='' value='Search' />
+</form>
+<% end %>
+
+<p class='sub'>
+  Showing <%= start %> to <%= start + delayed.size %> of <b><%= size %></b> timestamps
+</p>
+
+
+<table>
+  <tr>
+    <th></th>
+    <th>Timestamp</th>
+    <th>Job count</th>
+    <th>Class</th>
+    <th>Args</th>
+		<th>Queue</th>
+  </tr>
+	  <% delayed.each do |timestamp| %>
+	    <tr>
+	      <td>
+	        <form action="<%= url "/delayed/queue_now" %>" method="post" style="margin-top: 0px;">
+	          <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>
+				<td><%= h(job['queue'].inspect) if job && delayed_timestamp_size == 1 %></td>
+	    </tr>
+	  <% end %>
+</table>
+
+
+<%= partial :next_more, :start => start, :count => count, :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,39 @@
+<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><%= (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/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,25 @@
+# require 'resque/tasks'
+# will give you the resque tasks
+
+namespace :resque do
+  task :setup
+
+  desc "Start Resque Scheduler"
+  task :scheduler => :scheduler_setup do
+    gem 'resque-mongo'
+    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 = '2.0.2'
+end