resque-admin-scheduler 1.0.2 → 1.3.0

data/lib/resque_admin/scheduler/server.rb

@@ -0,0 +1,268 @@
+# vim:fileencoding=utf-8
+require 'resque_admin-scheduler'
+require 'resque_admin/server'
+require 'tilt/erb'
+require 'json'
+
+# Extend ResqueAdmin::Server to add tabs
+module ResqueAdmin
+  module Scheduler
+    module Server
+      TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S %z'.freeze
+
+      unless defined?(::ResqueAdmin::Scheduler::Server::VIEW_PATH)
+        VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
+      end
+
+      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
+          ResqueAdmin.reload_schedule! if ResqueAdmin::Scheduler.dynamic
+          erb scheduler_template('scheduler')
+        end
+
+        def schedule_requeue
+          @job_name = params['job_name'] || params[:job_name]
+          config = ResqueAdmin.schedule[@job_name]
+          @parameters = config['parameters'] || config[:parameters]
+          if @parameters
+            erb scheduler_template('requeue-params')
+          else
+            ResqueAdmin::Scheduler.enqueue_from_config(config)
+            redirect u('/overview')
+          end
+        end
+
+        def schedule_requeue_with_params
+          job_name = params['job_name'] || params[:job_name]
+          config = ResqueAdmin.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_admin job
+          config = config.merge('args' => config_args)
+          ResqueAdmin::Scheduler.enqueue_from_config(config)
+          redirect u('/overview')
+        end
+
+        def delete_schedule
+          if ResqueAdmin::Scheduler.dynamic
+            job_name = params['job_name'] || params[:job_name]
+            ResqueAdmin.remove_schedule(job_name)
+          end
+          redirect u('/schedule')
+        end
+
+        def delayed
+          erb scheduler_template('delayed')
+        end
+
+        def delayed_jobs_klass
+          begin
+            klass = ResqueAdmin::Scheduler::Util.constantize(params[:klass])
+            @args = JSON.load(URI.decode(params[:args]))
+            @timestamps = ResqueAdmin.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
+          formatted_time = Time.at(timestamp).strftime(
+            ::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT
+          )
+
+          if timestamp > 0
+            unless ResqueAdmin::Scheduler.enqueue_next_item(timestamp)
+              @error_message = "Unable to remove item at #{formatted_time}"
+            end
+          else
+            @error_message = "Incorrect timestamp #{formatted_time}"
+          end
+
+          erb scheduler_template('delayed')
+        end
+
+        def delayed_cancel_now
+          klass = ResqueAdmin::Scheduler::Util.constantize(params['klass'])
+          timestamp = params['timestamp']
+          args = ResqueAdmin.decode params['args']
+          ResqueAdmin.remove_delayed_job_from_timestamp(timestamp, klass, *args)
+          redirect u('/delayed')
+        end
+
+        def delayed_clear
+          ResqueAdmin.reset_delayed_queue
+          redirect u('delayed')
+        end
+      end
+
+      module HelperMethods
+        def format_time(t)
+          t.strftime(::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT)
+        end
+
+        def show_job_arguments(args)
+          Array(args).map(&:inspect).join("\n")
+        end
+
+        def queue_from_class_name(class_name)
+          ResqueAdmin.queue_from_class(
+            ResqueAdmin::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
+
+          ResqueAdmin.queues.each do |queue|
+            queued = ResqueAdmin.peek(queue, 0, ResqueAdmin.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.tr('_', ' ')} #{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 rails_env(name).nil?
+          rails_env(name).split(/[\s,]+/).include?(ResqueAdmin::Scheduler.env)
+        end
+
+        def rails_env(name)
+          ResqueAdmin.schedule[name]['rails_env'] || ResqueAdmin.schedule[name]['env']
+        end
+
+        def scheduler_view(filename, options = {}, locals = {})
+          source = File.read(File.join(VIEW_PATH, "#{filename}.erb"))
+          erb source, options, locals
+        end
+
+        private
+
+        def working_jobs_for_worker(worker)
+          [].tap do |results|
+            working = [*ResqueAdmin.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 = ResqueAdmin.delayed_queue_schedule_size
+            ResqueAdmin.delayed_queue_peek(0, schedule_size).each do |d|
+              ResqueAdmin.delayed_timestamp_peek(
+                d, 0, ResqueAdmin.delayed_timestamp_size(d)
+              ).each do |j|
+                dels << j.merge!('timestamp' => d)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ResqueAdmin::Server.tabs << 'Schedule'
+ResqueAdmin::Server.tabs << 'Delayed'
+
+ResqueAdmin::Server.class_eval do
+  include ResqueAdmin::Scheduler::Server
+end

data/lib/resque_admin/scheduler/signal_handling.rb

@@ -0,0 +1,40 @@
+# vim:fileencoding=utf-8
+
+module ResqueAdmin
+  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
+        (Signal.list.keys & %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 && @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_admin/scheduler/tasks.rb

@@ -0,0 +1,25 @@
+# vim:fileencoding=utf-8
+
+require 'resque_admin/tasks'
+require 'resque_admin-scheduler'
+
+namespace :resque_admin do
+  task :setup
+
+  def scheduler_cli
+    @scheduler_cli ||= ResqueAdmin::Scheduler::Cli.new(
+      %W(#{ENV['RESQUE_SCHEDULER_OPTIONS']})
+    )
+  end
+
+  desc 'Start ResqueAdmin Scheduler'
+  task scheduler: :scheduler_setup do
+    scheduler_cli.setup_env
+    scheduler_cli.run_forever
+  end
+
+  task :scheduler_setup do
+    scheduler_cli.parse_options
+    Rake::Task['resque_admin:setup'].invoke unless scheduler_cli.pre_setup
+  end
+end

data/lib/resque_admin/scheduler/util.rb

@@ -0,0 +1,39 @@
+# vim:fileencoding=utf-8
+
+module ResqueAdmin
+  module Scheduler
+    class Util
+      # In order to upgrade to resque_admin(1.25) which has deprecated following
+      # methods, we just added these usefull helpers back to use in ResqueAdmin
+      # Scheduler.  refer to:
+      # https://github.com/resque_admin/resque_admin-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] : []
+
+          constant = if constant.const_defined?(name, *args)
+                       constant.const_get(name)
+                     else
+                       constant.const_missing(name)
+                     end
+        end
+        constant
+      end
+
+      def self.classify(dashed_word)
+        dashed_word.split('-').map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/{resque → resque_admin}/scheduler/version.rb

@@ -1,7 +1,7 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
-    VERSION = '1.0.2'.freeze
+    VERSION = '1.3.0'.freeze
   end
 end

data/lib/{resque → resque_admin}/scheduler.rb

@@ -7,18 +7,18 @@ require_relative 'scheduler/logger_builder'
 require_relative 'scheduler/signal_handling'
 require_relative 'scheduler/failure_handler'
 
-module Resque
+module ResqueAdmin
   module Scheduler
-    autoload :Cli, 'resque/scheduler/cli'
-    autoload :Extension, 'resque/scheduler/extension'
-    autoload :Util, 'resque/scheduler/util'
-    autoload :VERSION, 'resque/scheduler/version'
+    autoload :Cli, 'resque_admin/scheduler/cli'
+    autoload :Extension, 'resque_admin/scheduler/extension'
+    autoload :Util, 'resque_admin/scheduler/util'
+    autoload :VERSION, 'resque_admin/scheduler/version'
 
     private
 
-    extend Resque::Scheduler::Locking
-    extend Resque::Scheduler::Configuration
-    extend Resque::Scheduler::SignalHandling
+    extend ResqueAdmin::Scheduler::Locking
+    extend ResqueAdmin::Scheduler::Configuration
+    extend ResqueAdmin::Scheduler::SignalHandling
 
     public
 
@@ -38,8 +38,8 @@ module Resque
         # trap signals
         register_signal_handlers
 
-        # Quote from the resque/worker.
-        # Fix buffering so we can `rake resque:scheduler > scheduler.log` and
+        # Quote from the resque_admin/worker.
+        # Fix buffering so we can `rake resque_admin:scheduler > scheduler.log` and
         # get output from the child in there.
         $stdout.sync = true
         $stderr.sync = true
@@ -84,22 +84,22 @@ module Resque
         end
       end
 
-      # Pulls the schedule from Resque.schedule and loads it into the
+      # Pulls the schedule from ResqueAdmin.schedule and loads it into the
       # rufus scheduler instance
       def load_schedule!
         procline 'Loading Schedule'
 
         # Need to load the schedule from redis for the first time if dynamic
-        Resque.reload_schedule! if dynamic
+        ResqueAdmin.reload_schedule! if dynamic
 
-        log! 'Schedule empty! Set Resque.schedule' if Resque.schedule.empty?
+        log! 'Schedule empty! Set ResqueAdmin.schedule' if ResqueAdmin.schedule.empty?
 
         @scheduled_jobs = {}
 
-        Resque.schedule.each do |name, config|
+        ResqueAdmin.schedule.each do |name, config|
           load_schedule_job(name, config)
         end
-        Resque.redis.del(:schedules_changed)
+        ResqueAdmin.redis.del(:schedules_changed)
         procline 'Schedules Loaded'
       end
 
@@ -125,9 +125,9 @@ module Resque
       # in @scheduled_jobs
       def load_schedule_job(name, config)
         # If `rails_env` or `env` is set in the config, load jobs only if they
-        # are meant to be loaded in `Resque::Scheduler.env`.  If `rails_env` or
+        # are meant to be loaded in `ResqueAdmin::Scheduler.env`.  If `rails_env` or
         # `env` is missing, the job should be scheduled regardless of the value
-        # of `Resque::Scheduler.env`.
+        # of `ResqueAdmin::Scheduler.env`.
 
         configured_env = config['rails_env'] || config['env']
 
@@ -160,8 +160,8 @@ module Resque
 
       # Returns true if the given schedule config hash matches the current env
       def rails_env_matches?(config)
-        warn '`Resque::Scheduler.rails_env_matches?` is deprecated. ' \
-             'Please use `Resque::Scheduler.env_matches?` instead.'
+        warn '`ResqueAdmin::Scheduler.rails_env_matches?` is deprecated. ' \
+             'Please use `ResqueAdmin::Scheduler.env_matches?` instead.'
         config['rails_env'] && env &&
           config['rails_env'].split(/[\s,]+/).include?(env)
       end
@@ -175,18 +175,18 @@ module Resque
       # Handles queueing delayed items
       # at_time - Time to start scheduling items (default: now).
       def handle_delayed_items(at_time = nil)
-        timestamp = Resque.next_delayed_timestamp(at_time)
+        timestamp = ResqueAdmin.next_delayed_timestamp(at_time)
         if timestamp
           procline 'Processing Delayed Items'
           until timestamp.nil?
             enqueue_delayed_items_for_timestamp(timestamp)
-            timestamp = Resque.next_delayed_timestamp(at_time)
+            timestamp = ResqueAdmin.next_delayed_timestamp(at_time)
           end
         end
       end
 
       def enqueue_next_item(timestamp)
-        item = Resque.next_item_for_timestamp(timestamp)
+        item = ResqueAdmin.next_item_for_timestamp(timestamp)
 
         if item
           log "queuing #{item['class']} [delayed]"
@@ -213,7 +213,7 @@ module Resque
       def enqueue(config)
         enqueue_from_config(config)
       rescue => e
-        Resque::Scheduler.failure_handler.on_enqueue_failure(config, e)
+        ResqueAdmin::Scheduler.failure_handler.on_enqueue_failure(config, e)
       end
 
       def handle_shutdown
@@ -228,7 +228,7 @@ module Resque
 
         klass_name = job_config['class'] || job_config[:class]
         begin
-          klass = Resque::Scheduler::Util.constantize(klass_name)
+          klass = ResqueAdmin::Scheduler::Util.constantize(klass_name)
         rescue NameError
           klass = klass_name
         end
@@ -236,45 +236,45 @@ module Resque
         params = args.is_a?(Hash) ? [args] : Array(args)
         queue = job_config['queue'] ||
                 job_config[:queue] ||
-                Resque.queue_from_class(klass)
+                ResqueAdmin.queue_from_class(klass)
         # Support custom job classes like those that inherit from
-        # Resque::JobWithStatus (resque-status)
+        # ResqueAdmin::JobWithStatus (resque_admin-status)
         job_klass = job_config['custom_job_class']
-        if job_klass && job_klass != 'Resque::Job'
+        if job_klass && job_klass != 'ResqueAdmin::Job'
           # The custom job class API must offer a static "scheduled" method. If
           # the custom job class can not be constantized (via a requeue call
           # from the web perhaps), fall back to enqueing normally via
-          # Resque::Job.create.
+          # ResqueAdmin::Job.create.
           begin
-            Resque::Scheduler::Util.constantize(job_klass).scheduled(
+            ResqueAdmin::Scheduler::Util.constantize(job_klass).scheduled(
               queue, klass_name, *params
             )
           rescue NameError
             # Note that the custom job class (job_config['custom_job_class'])
             # is the one enqueued
-            Resque::Job.create(queue, job_klass, *params)
+            ResqueAdmin::Job.create(queue, job_klass, *params)
           end
         else
           # Hack to avoid havoc for people shoving stuff into queues
           # for non-existent classes (for example: running scheduler in
           # one app that schedules for another.
           if Class === klass
-            Resque::Scheduler::Plugin.run_before_delayed_enqueue_hooks(
+            ResqueAdmin::Scheduler::Plugin.run_before_delayed_enqueue_hooks(
               klass, *params
             )
 
             # If the class is a custom job class, call self#scheduled on it.
-            # This allows you to do things like Resque.enqueue_at(timestamp,
-            # CustomJobClass). Otherwise, pass off to Resque.
+            # This allows you to do things like ResqueAdmin.enqueue_at(timestamp,
+            # CustomJobClass). Otherwise, pass off to ResqueAdmin.
             if klass.respond_to?(:scheduled)
               klass.scheduled(queue, klass_name, *params)
             else
-              Resque.enqueue_to(queue, klass, *params)
+              ResqueAdmin.enqueue_to(queue, klass, *params)
             end
           else
             # This will not run the before_hooks in rescue, but will at least
             # queue the job.
-            Resque::Job.create(queue, klass, *params)
+            ResqueAdmin::Job.create(queue, klass, *params)
           end
         end
       end
@@ -299,15 +299,15 @@ module Resque
       end
 
       def update_schedule
-        if Resque.redis.scard(:schedules_changed) > 0
+        if ResqueAdmin.redis.scard(:schedules_changed) > 0
           procline 'Updating schedule'
           loop do
-            schedule_name = Resque.redis.spop(:schedules_changed)
+            schedule_name = ResqueAdmin.redis.spop(:schedules_changed)
             break unless schedule_name
-            Resque.reload_schedule!
-            if Resque.schedule.keys.include?(schedule_name)
+            ResqueAdmin.reload_schedule!
+            if ResqueAdmin.schedule.keys.include?(schedule_name)
               unschedule_job(schedule_name)
-              load_schedule_job(schedule_name, Resque.schedule[schedule_name])
+              load_schedule_job(schedule_name, ResqueAdmin.schedule[schedule_name])
             else
               unschedule_job(schedule_name)
             end
@@ -405,11 +405,11 @@ module Resque
       end
 
       def failure_handler
-        @failure_handler ||= Resque::Scheduler::FailureHandler
+        @failure_handler ||= ResqueAdmin::Scheduler::FailureHandler
       end
 
       def logger
-        @logger ||= Resque::Scheduler::LoggerBuilder.new(
+        @logger ||= ResqueAdmin::Scheduler::LoggerBuilder.new(
           quiet: quiet,
           verbose: verbose,
           log_dev: logfile,
@@ -422,7 +422,7 @@ module Resque
       def enqueue_recurring(name, config)
         if master?
           log! "queueing #{config['class']} (#{name})"
-          Resque.last_enqueued_at(name, Time.now.to_s)
+          ResqueAdmin.last_enqueued_at(name, Time.now.to_s)
           enqueue(config)
         end
       end
@@ -440,7 +440,7 @@ module Resque
       end
 
       def internal_name
-        "resque-scheduler-#{Resque::Scheduler::VERSION}"
+        "resque_admin-scheduler-#{ResqueAdmin::Scheduler::VERSION}"
       end
     end
   end

data/tasks/resque_admin_scheduler.rake

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'resque_admin/scheduler/tasks'