resque-scheduler 2.5.5 → 3.0.0

data/lib/resque/scheduler/server.rb

@@ -0,0 +1,246 @@
+# vim:fileencoding=utf-8
+require 'resque-scheduler'
+require 'resque/server'
+require 'json'
+
+# Extend Resque::Server to add tabs
+module Resque
+  module Scheduler
+    module Server
+      def self.included(base)
+        base.class_eval do
+          helpers { include HelperMethods }
+          include ServerMethods
+
+          get('/schedule') { schedule }
+          post('/schedule/requeue') { schedule_requeue }
+          post('/schedule/requeue_with_params') do
+            schedule_requeue_with_params
+          end
+          delete('/schedule') { delete_schedule }
+          get('/delayed') { delayed }
+          get('/delayed/jobs/:klass') { delayed_jobs_klass }
+          post('/delayed/search') { delayed_search }
+          get('/delayed/:timestamp') { delayed_timestamp }
+          post('/delayed/queue_now') { delayed_queue_now }
+          post('/delayed/cancel_now') { delayed_cancel_now }
+          post('/delayed/clear') { delayed_clear }
+        end
+      end
+
+      module ServerMethods
+        def schedule
+          Resque.reload_schedule! if Resque::Scheduler.dynamic
+          erb scheduler_template('scheduler')
+        end
+
+        def schedule_requeue
+          @job_name = params['job_name'] || params[:job_name]
+          config = Resque.schedule[@job_name]
+          @parameters = config['parameters'] || config[:parameters]
+          if @parameters
+            erb scheduler_template('requeue-params')
+          else
+            Resque::Scheduler.enqueue_from_config(config)
+            redirect u('/overview')
+          end
+        end
+
+        def schedule_requeue_with_params
+          job_name = params['job_name'] || params[:job_name]
+          config = Resque.schedule[job_name]
+          # Build args hash from post data (removing the job name)
+          submitted_args = params.reject do |key, _value|
+            key == 'job_name' || key == :job_name
+          end
+
+          # Merge constructed args hash with existing args hash for
+          # the job, if it exists
+          config_args = config['args'] || config[:args] || {}
+          config_args = config_args.merge(submitted_args)
+
+          # Insert the args hash into config and queue the resque job
+          config = config.merge('args' => config_args)
+          Resque::Scheduler.enqueue_from_config(config)
+          redirect u('/overview')
+        end
+
+        def delete_schedule
+          if Resque::Scheduler.dynamic
+            job_name = params['job_name'] || params[:job_name]
+            Resque.remove_schedule(job_name)
+          end
+          redirect u('/schedule')
+        end
+
+        def delayed
+          erb scheduler_template('delayed')
+        end
+
+        def delayed_jobs_klass
+          begin
+            klass = Resque::Scheduler::Util.constantize(params[:klass])
+            @args = JSON.load(URI.decode(params[:args]))
+            @timestamps = Resque.scheduled_at(klass, *@args)
+          rescue
+            @timestamps = []
+          end
+
+          erb scheduler_template('delayed_schedules')
+        end
+
+        def delayed_search
+          @jobs = find_job(params[:search])
+          erb scheduler_template('search')
+        end
+
+        def delayed_timestamp
+          erb scheduler_template('delayed_timestamp')
+        end
+
+        def delayed_queue_now
+          timestamp = params['timestamp'].to_i
+          if timestamp > 0
+            Resque::Scheduler.enqueue_delayed_items_for_timestamp(timestamp)
+          end
+          redirect u('/overview')
+        end
+
+        def delayed_cancel_now
+          klass = Resque::Scheduler::Util.constantize(params['klass'])
+          timestamp = params['timestamp']
+          args = Resque.decode params['args']
+          Resque.remove_delayed_job_from_timestamp(timestamp, klass, *args)
+          redirect u('/delayed')
+        end
+
+        def delayed_clear
+          Resque.reset_delayed_queue
+          redirect u('delayed')
+        end
+      end
+
+      module HelperMethods
+        def render_partial(partial)
+          erb partial, layout: false
+        end
+
+        def format_time(t)
+          t.strftime('%Y-%m-%d %H:%M:%S %z')
+        end
+
+        def queue_from_class_name(class_name)
+          Resque.queue_from_class(
+            Resque::Scheduler::Util.constantize(class_name)
+          )
+        end
+
+        def find_job(worker)
+          worker = worker.downcase
+          results = working_jobs_for_worker(worker)
+
+          dels = delayed_jobs_for_worker(worker)
+          results += dels.select do |j|
+            j['class'].downcase.include?(worker) &&
+              j.merge!('where_at' => 'delayed')
+          end
+
+          Resque.queues.each do |queue|
+            queued = Resque.peek(queue, 0, Resque.size(queue))
+            queued = [queued] unless queued.is_a?(Array)
+            results += queued.select do |j|
+              j['class'].downcase.include?(worker) &&
+                j.merge!('queue' => queue, 'where_at' => 'queued')
+            end
+          end
+
+          results
+        end
+
+        def schedule_interval(config)
+          if config['every']
+            schedule_interval_every(config['every'])
+          elsif config['cron']
+            'cron: ' + config['cron'].to_s
+          else
+            'Not currently scheduled'
+          end
+        end
+
+        def schedule_interval_every(every)
+          every = [*every]
+          s = 'every: ' << every.first
+
+          return s unless every.length > 1
+
+          s << ' ('
+          meta = every.last.map do |key, value|
+            "#{key.to_s.gsub(/_/, ' ')} #{value}"
+          end
+          s << meta.join(', ') << ')'
+        end
+
+        def schedule_class(config)
+          if config['class'].nil? && !config['custom_job_class'].nil?
+            config['custom_job_class']
+          else
+            config['class']
+          end
+        end
+
+        def scheduler_template(name)
+          File.read(
+            File.expand_path("../server/views/#{name}.erb", __FILE__)
+          )
+        end
+
+        def scheduled_in_this_env?(name)
+          return true if Resque.schedule[name]['rails_env'].nil?
+          rails_env(name).split(/[\s,]+/).include?(Resque::Scheduler.env)
+        end
+
+        def rails_env(name)
+          Resque.schedule[name]['rails_env']
+        end
+
+        private
+
+        def working_jobs_for_worker(worker)
+          [].tap do |results|
+            working = [*Resque.working]
+            work = working.select do |w|
+              w.job && w.job['payload'] &&
+                w.job['payload']['class'].downcase.include?(worker)
+            end
+            work.each do |w|
+              results += [
+                w.job['payload'].merge(
+                  'queue' => w.job['queue'], 'where_at' => 'working'
+                )
+              ]
+            end
+          end
+        end
+
+        def delayed_jobs_for_worker(_worker)
+          [].tap do |dels|
+            schedule_size = Resque.delayed_queue_schedule_size
+            Resque.delayed_queue_peek(0, schedule_size).each do |d|
+              Resque.delayed_timestamp_peek(
+                d, 0, Resque.delayed_timestamp_size(d)).each do |j|
+                  dels << j.merge!('timestamp' => d)
+                end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Resque::Server.tabs << 'Schedule'
+Resque::Server.tabs << 'Delayed'
+
+Resque::Server.class_eval do
+  include Resque::Scheduler::Server
+end

data/lib/{resque_scheduler → resque/scheduler}/server/views/delayed.erb

@@ -1,7 +1,7 @@
 <h1>Delayed Jobs</h1>
 <%- size = resque.delayed_queue_schedule_size %>
 
-<%= erb File.read(File.join(File.dirname(__FILE__), 'server/views/search_form.erb')) %>
+<%= render_partial File.read(File.join(File.dirname(__FILE__), 'server/views/search_form.erb')) %>
 
 <p class='intro'>
   This list below contains the timestamps for scheduled delayed jobs.
@@ -57,3 +57,4 @@
 <% end %>
 
 <%= partial :next_more, :start => start, :size => size %>
+

data/lib/{resque_scheduler → resque/scheduler}/server/views/scheduler.erb

@@ -5,9 +5,12 @@
   a job immediately.
   Server local time: <%= Time.now %>
 </p>
-
+<div style="overflow-y: auto; width:100%; padding: 0px 5px;">
 <table>
   <tr>
+    <% if Resque::Scheduler.dynamic %>
+      <th></th>
+    <% end %>
     <th></th>
     <th>Name</th>
     <th>Description</th>
@@ -15,10 +18,20 @@
     <th>Class</th>
     <th>Queue</th>
     <th>Arguments</th>
+    <th>Last Enqueued</th>
   </tr>
   <% Resque.schedule.keys.sort.select { |n| scheduled_in_this_env?(n) }.each do |name| %>
     <% config = Resque.schedule[name] %>
     <tr>
+      <% if Resque::Scheduler.dynamic %>
+        <td style="padding-top: 12px; padding-bottom: 2px; width: 10px">
+          <form action="<%= u "/schedule" %>" method="post" style="margin-left: 0">
+            <input type="hidden" name="job_name" value="<%= h name %>">
+            <input type="hidden" name="_method" value="delete">
+            <input type="submit" value="Delete">
+          </form>
+        </td>
+      <% end %>
       <td style="padding-top: 12px; padding-bottom: 2px; width: 10px">
         <form action="<%= u "/schedule/requeue" %>" method="post" style="margin-left: 0">
           <input type="hidden" name="job_name" value="<%= h name %>">
@@ -31,6 +44,8 @@
       <td><%= h schedule_class(config) %></td>
       <td><%= h config['queue'] || queue_from_class_name(config['class']) %></td>
       <td><%= h config['args'].inspect %></td>
+      <td><%= h Resque.get_last_enqueued_at(name) || 'Never' %></td>
     </tr>
   <% end %>
 </table>
+</div>

data/lib/{resque_scheduler → resque/scheduler}/server/views/search.erb

@@ -1,5 +1,5 @@
 <h1>Search Results</h1>
-<%= erb File.read(File.join(File.dirname(__FILE__), 'server/views/search_form.erb')) %>
+<%= render_partial File.read(File.join(File.dirname(__FILE__), 'server/views/search_form.erb')) %>
 <hr>
 <% delayed = @jobs.select { |j| j['where_at'] == 'delayed' } %>
 <h1>Delayed jobs</h1>
@@ -70,3 +70,4 @@
 </table>
 
 
+

data/lib/resque/scheduler/signal_handling.rb

@@ -0,0 +1,40 @@
+# vim:fileencoding=utf-8
+
+module Resque
+  module Scheduler
+    module SignalHandling
+      attr_writer :signal_queue
+
+      def signal_queue
+        @signal_queue ||= []
+      end
+
+      # For all signals, set the shutdown flag and wait for current
+      # poll/enqueing to finish (should be almost instant).  In the
+      # case of sleeping, exit immediately.
+      def register_signal_handlers
+        %w(INT TERM USR1 USR2 QUIT).each do |sig|
+          trap(sig) do
+            signal_queue << sig
+            # break sleep in the primary scheduler thread, alowing
+            # the signal queue to get processed as soon as possible.
+            @th.wakeup if @th.alive?
+          end
+        end
+      end
+
+      def handle_signals
+        loop do
+          sig = signal_queue.shift
+          break unless sig
+          log! "Got #{sig} signal"
+          case sig
+          when 'INT', 'TERM', 'QUIT' then shutdown
+          when 'USR1' then print_schedule
+          when 'USR2' then reload_schedule!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/{resque_scheduler → resque/scheduler}/tasks.rb

@@ -2,13 +2,13 @@
 
 require 'English'
 require 'resque/tasks'
-require 'resque_scheduler'
+require 'resque-scheduler'
 
 namespace :resque do
   task :setup
 
   def scheduler_cli
-    @scheduler_cli ||= ResqueScheduler::Cli.new(
+    @scheduler_cli ||= Resque::Scheduler::Cli.new(
       %W(#{ENV['RESQUE_SCHEDULER_OPTIONS']})
     )
   end
@@ -21,8 +21,6 @@ namespace :resque do
 
   task :scheduler_setup do
     scheduler_cli.parse_options
-    unless scheduler_cli.pre_setup
-      Rake::Task['resque:setup'].invoke
-    end
+    Rake::Task['resque:setup'].invoke unless scheduler_cli.pre_setup
   end
 end

data/lib/resque/scheduler/util.rb

@@ -0,0 +1,41 @@
+# vim:fileencoding=utf-8
+
+module Resque
+  module Scheduler
+    class Util
+      # In order to upgrade to resque(1.25) which has deprecated following
+      # methods, we just added these usefull helpers back to use in Resque
+      # Scheduler.  refer to:
+      # https://github.com/resque/resque-scheduler/pull/273
+
+      def self.constantize(camel_cased_word)
+        camel_cased_word = camel_cased_word.to_s
+
+        if camel_cased_word.include?('-')
+          camel_cased_word = classify(camel_cased_word)
+        end
+
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          args = Module.method(:const_get).arity != 1 ? [false] : []
+
+          if constant.const_defined?(name, *args)
+            constant = constant.const_get(name)
+          else
+            constant = constant.const_missing(name)
+          end
+        end
+        constant
+      end
+
+      def self.classify(dashed_word)
+        dashed_word.split('-').each do|part|
+          part[0] = part[0].chr.upcase
+        end.join
+      end
+    end
+  end
+end

data/lib/resque/scheduler/version.rb

@@ -0,0 +1,7 @@
+# vim:fileencoding=utf-8
+
+module Resque
+  module Scheduler
+    VERSION = '3.0.0'
+  end
+end

data/resque-scheduler.gemspec

@@ -1,36 +1,38 @@
 # vim:fileencoding=utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'resque_scheduler/version'
+require 'resque/scheduler/version'
 
 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.
+  spec.name = 'resque-scheduler'
+  spec.version = Resque::Scheduler::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.}
+    Also supports queueing jobs on a fixed, cron-like schedule.)
   spec.license = 'MIT'
 
-  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.files = `git ls-files`.split("\n")
+  spec.executables = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(/^test\//)
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'json'
+  spec.add_development_dependency 'kramdown'
   spec.add_development_dependency 'mocha'
   spec.add_development_dependency 'pry'
   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'
-  spec.add_development_dependency 'simplecov' unless RUBY_VERSION < '1.9'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'yard'
 
   spec.add_runtime_dependency 'mono_logger', '~> 1.0'
-  spec.add_runtime_dependency 'redis', '~> 3.0.4'
-  spec.add_runtime_dependency 'resque', '~> 1.25.1'
-  spec.add_runtime_dependency 'rufus-scheduler', '~> 2.0.24'
+  spec.add_runtime_dependency 'redis', '~> 3.0'
+  spec.add_runtime_dependency 'resque', '~> 1.25'
+  spec.add_runtime_dependency 'rufus-scheduler', '~> 2.0'
 end