resque-admin-scheduler 1.0.2 → 1.3.0

data/lib/resque/scheduler_admin/logger_builder.rb

@@ -0,0 +1,72 @@
+# vim:fileencoding=utf-8
+
+require 'mono_logger'
+
+module ResqueAdmin
+  module Scheduler
+    # Just builds a logger, with specified verbosity and destination.
+    # The simplest example:
+    #
+    #   ResqueAdmin::Scheduler::LoggerBuilder.new.build
+    class LoggerBuilder
+      # Initializes new instance of the builder
+      #
+      # Pass :opts Hash with
+      #   - :quiet if logger needs to be silent for all levels. Default - false
+      #   - :verbose if there is a need in debug messages. Default - false
+      #   - :log_dev to output logs into a desired file. Default - STDOUT
+      #   - :format log format, either 'text' or 'json'. Default - 'text'
+      #
+      # Example:
+      #
+      #   LoggerBuilder.new(
+      #     :quiet => false, :verbose => true, :log_dev => 'log/scheduler_admin.log'
+      #   )
+      def initialize(opts = {})
+        @quiet = !!opts[:quiet]
+        @verbose = !!opts[:verbose]
+        @log_dev = opts[:log_dev] || $stdout
+        @format = opts[:format] || 'text'
+      end
+
+      # Returns an instance of MonoLogger
+      def build
+        logger = MonoLogger.new(@log_dev)
+        logger.level = level
+        logger.formatter = send(:"#{@format}_formatter")
+        logger
+      end
+
+      private
+
+      def level
+        if @verbose && !@quiet
+          MonoLogger::DEBUG
+        elsif !@quiet
+          MonoLogger::INFO
+        else
+          MonoLogger::FATAL
+        end
+      end
+
+      def text_formatter
+        proc do |severity, datetime, _progname, msg|
+          "resque_admin-scheduler_admin: [#{severity}] #{datetime.iso8601}: #{msg}\n"
+        end
+      end
+
+      def json_formatter
+        proc do |severity, datetime, progname, msg|
+          require 'json'
+          JSON.dump(
+            name: 'resque_admin-scheduler_admin',
+            progname: progname,
+            level: severity,
+            timestamp: datetime.iso8601,
+            msg: msg
+          ) + "\n"
+        end
+      end
+    end
+  end
+end

data/lib/resque/scheduler_admin/scheduling_extensions.rb

@@ -0,0 +1,141 @@
+# vim:fileencoding=utf-8
+
+module ResqueAdmin
+  module Scheduler
+    module SchedulingExtensions
+      # Accepts a new schedule configuration of the form:
+      #
+      #   {
+      #     "MakeTea" => {
+      #       "every" => "1m" },
+      #     "some_name" => {
+      #       "cron"        => "5/* * * *",
+      #       "class"       => "DoSomeWork",
+      #       "args"        => "work on this string",
+      #       "description" => "this thing works it"s butter off" },
+      #     ...
+      #   }
+      #
+      # Hash keys can be anything and are used to describe and reference
+      # the scheduled job. If the "class" argument is missing, the key
+      # is used implicitly as "class" argument - in the "MakeTea" example,
+      # "MakeTea" is used both as job name and resque_admin worker class.
+      #
+      # Any jobs that were in the old schedule, but are not
+      # present in the new schedule, will be removed.
+      #
+      # :cron can be any cron scheduling string
+      #
+      # :every can be used in lieu of :cron. see rufus-scheduler_admin's 'every'
+      # usage for valid syntax. If :cron is present it will take precedence
+      # over :every.
+      #
+      # :class must be a resque_admin worker class. If it is missing, the job name
+      # (hash key) will be used as :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)
+        @non_persistent_schedules = nil
+        prepared_schedules = prepare_schedules(schedule_hash)
+
+        prepared_schedules.each do |schedule, config|
+          set_schedule(schedule, config, false)
+        end
+
+        # ensure only return the successfully saved data!
+        reload_schedule!
+      end
+
+      # Returns the schedule hash
+      def schedule
+        @schedule ||= all_schedules
+        @schedule || {}
+      end
+
+      # reloads the schedule from redis and memory
+      def reload_schedule!
+        @schedule = all_schedules
+      end
+
+      # gets the schedules as it exists in redis
+      def all_schedules
+        non_persistent_schedules.merge(persistent_schedules)
+      end
+
+      # Create or update a schedule with the provided name and configuration.
+      #
+      # Note: values for class and custom_job_class need to be strings,
+      # not constants.
+      #
+      #    ResqueAdmin.set_schedule('some_job', {:class => 'SomeJob',
+      #                                     :every => '15mins',
+      #                                     :queue => 'high',
+      #                                     :args => '/tmp/poop'})
+      #
+      # Preventing a reload is optional and available to batch operations
+      def set_schedule(name, config, reload = true)
+        persist = config.delete(:persist) || config.delete('persist')
+
+        if persist
+          redis.hset(:persistent_schedules, name, encode(config))
+        else
+          non_persistent_schedules[name] = decode(encode(config))
+        end
+
+        redis.sadd(:schedules_changed, name)
+        reload_schedule! if reload
+      end
+
+      # retrive the schedule configuration for the given name
+      def fetch_schedule(name)
+        schedule[name]
+      end
+
+      # remove a given schedule by name
+      def remove_schedule(name)
+        non_persistent_schedules.delete(name)
+        redis.hdel(:persistent_schedules, name)
+        redis.sadd(:schedules_changed, name)
+
+        reload_schedule!
+      end
+
+      private
+
+      # we store our non-persistent schedules in this hash
+      def non_persistent_schedules
+        @non_persistent_schedules ||= {}
+      end
+
+      # reads the persistent schedules from redis
+      def persistent_schedules
+        redis.hgetall(:persistent_schedules).tap do |h|
+          h.each do |name, config|
+            h[name] = decode(config)
+          end
+        end
+      end
+
+      def prepare_schedules(schedule_hash)
+        prepared_hash = {}
+        schedule_hash.each do |name, job_spec|
+          job_spec = job_spec.dup
+          unless job_spec.key?('class') || job_spec.key?(:class)
+            job_spec['class'] = name
+          end
+          prepared_hash[name] = job_spec
+        end
+        prepared_hash
+      end
+    end
+  end
+end

data/lib/resque/scheduler_admin/server/views/delayed.erb

@@ -0,0 +1,63 @@
+<h1>Delayed Jobs</h1>
+<%- size = resque_admin.delayed_queue_schedule_size %>
+
+<%= scheduler_admin_view :search_form, layout: false %>
+
+<p style="font-color: red; font-weight: bold;">
+  <%= @error_message %>
+</p>
+
+<p class='intro'>
+  This list below contains the timestamps for scheduled delayed jobs.
+  Server local time: <%= Time.now %>
+</p>
+
+<p class='sub'>
+  Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%= size %></b> timestamps
+</p>
+
+<table>
+  <tr>
+    <th></th>
+    <th>Timestamp</th>
+    <th>Job count</th>
+    <th>Class</th>
+    <th>Args</th>
+    <th>All schedules</th>
+  </tr>
+  <% resque_admin.delayed_queue_peek(start, 20).each do |timestamp| %>
+    <tr>
+      <td>
+        <form action="<%= u "/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="<%= u "delayed/#{timestamp}" %>"><%= format_time(Time.at(timestamp)) %></a></td>
+      <td><%= delayed_timestamp_size = resque_admin.delayed_timestamp_size(timestamp) %></td>
+      <% job = resque_admin.delayed_timestamp_peek(timestamp, 0, 1).first %>
+      <td>
+        <% if job && delayed_timestamp_size == 1 %>
+          <%= h(job['class']) %>
+        <% else %>
+          <a href="<%= u "delayed/#{timestamp}" %>">see details</a>
+        <% end %>
+      </td>
+      <td><%= h(show_job_arguments(job['args'])) if job && delayed_timestamp_size == 1 %></td>
+      <td>
+        <% if job %>
+          <a href="<%=u URI("/delayed/jobs/#{job['class']}?args=" + URI.encode(job['args'].to_json)) %>">All schedules</a>
+        <% end %>
+      </td>
+    </tr>
+  <% end %>
+</table>
+
+<% if size > 0 %>
+  <br>
+  <form method="POST" action="<%=u 'delayed/clear'%>" class='clear-delayed'>
+    <input type='submit' name='' value='Clear Delayed Jobs' />
+  </form>
+<% end %>
+
+<%= partial :next_more, :start => start, :size => size %>

data/lib/resque/scheduler_admin/server/views/search.erb

@@ -0,0 +1,72 @@
+<h1>Search Results</h1>
+<%= scheduler_admin_view :search_form, layout: false %>
+<hr>
+<% delayed = @jobs.select { |j| j['where_at'] == 'delayed' } %>
+<h1>Delayed jobs</h1>
+<table class='jobs'>
+  <tr>
+    <th></th>
+    <th></th>
+    <th>Timestamp</th>
+    <th>Class</th>
+    <th>Args</th>
+  </tr>
+  <% delayed.each do |job| %>
+      <tr>
+        <td>
+          <form action="<%= u "/delayed/queue_now" %>" method="post">
+            <input type="hidden" name="timestamp" value="<%= job['timestamp'].to_i %>">
+            <input type="submit" value="Queue now">
+          </form>
+        </td>
+        <td>
+          <form action="<%= u "/delayed/cancel_now" %>" method="post">
+            <input type="hidden" name="timestamp" value="<%= job['timestamp'].to_i %>">
+            <input type="hidden" name="klass" value="<%= job['class'] %>">
+            <input type="hidden" name="args" value="<%= h(ResqueAdmin.encode job['args']) %>">
+            <input type="submit" value="Cancel Job">
+          </form>
+        </td>
+        <td class='args'><%= format_time(Time.at(job['timestamp'])) %></td>
+        <td class='class'><%= job['class'] %></td>
+        <td class='args'><%= h job['args'].inspect %></td>
+      </tr>
+  <% end %>
+</table>
+</h1>
+
+<% queued = @jobs.select { |j| j['where_at'] == 'queued' } %>
+<h1>Queued jobs</h1>
+<table class='jobs'>
+  <tr>
+    <th>Queue</th>
+    <th>Class</th>
+    <th>Args</th>
+  </tr>
+  <% queued.each do |job| %>
+  <tr>
+    <td class='class'><%= job['queue'] %></td>
+    <td class='class'><%= job['class'] %></td>
+    <td class='args'><%= h job['args'].inspect %></td>
+  </tr>
+  <% end %>
+</table>
+
+<% working = @jobs.select { |j| j['where_at'] == 'working' } %>
+<h1>Working jobs</h1>
+<table class='jobs'>
+  <tr>
+    <th>Queue</th>
+    <th>Class</th>
+    <th>Args</th>
+  </tr>
+  <% working.each do |job| %>
+  <tr>
+    <td class='class'><%= job['queue'] %></td>
+    <td class='class'><%= job['class'] %></td>
+    <td class='args'><%= h job['args'].inspect %></td>
+  </tr>
+  <% end %>
+</table>
+
+

data/lib/resque/scheduler_admin/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_admin 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/scheduler_admin/tasks.rb

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

data/lib/resque/scheduler_admin/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_admin/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-admin-scheduler.rb

@@ -0,0 +1,4 @@
+# vim:fileencoding=utf-8
+require_relative 'resque_admin/scheduler'
+
+ResqueAdmin.extend ResqueAdmin::Scheduler::Extension

data/lib/resque_admin/scheduler/cli.rb

@@ -0,0 +1,147 @@
+# vim:fileencoding=utf-8
+
+require 'optparse'
+
+module ResqueAdmin
+  module Scheduler
+    CLI_OPTIONS_ENV_MAPPING = {
+      app_name: 'APP_NAME',
+      background: 'BACKGROUND',
+      dynamic: 'DYNAMIC_SCHEDULE',
+      env: 'RAILS_ENV',
+      initializer_path: 'INITIALIZER_PATH',
+      logfile: 'LOGFILE',
+      logformat: 'LOGFORMAT',
+      quiet: 'QUIET',
+      pidfile: 'PIDFILE',
+      poll_sleep_amount: 'RESQUE_SCHEDULER_INTERVAL',
+      verbose: 'VERBOSE'
+    }.freeze
+
+    class Cli
+      BANNER = <<-EOF.gsub(/ {6}/, '')
+      Usage: resque_admin-scheduler [options]
+
+      Runs a resque_admin scheduler process directly (rather than via rake).
+
+      EOF
+      OPTIONS = [
+        {
+          args: ['-n', '--app-name [APP_NAME]',
+                 'Application name for procline'],
+          callback: ->(options) { ->(n) { options[:app_name] = n } }
+        },
+        {
+          args: ['-B', '--background', 'Run in the background [BACKGROUND]'],
+          callback: ->(options) { ->(b) { options[:background] = b } }
+        },
+        {
+          args: ['-D', '--dynamic-schedule',
+                 'Enable dynamic scheduling [DYNAMIC_SCHEDULE]'],
+          callback: ->(options) { ->(d) { options[:dynamic] = d } }
+        },
+        {
+          args: ['-E', '--environment [RAILS_ENV]', 'Environment name'],
+          callback: ->(options) { ->(e) { options[:env] = e } }
+        },
+        {
+          args: ['-I', '--initializer-path [INITIALIZER_PATH]',
+                 'Path to optional initializer ruby file'],
+          callback: ->(options) { ->(i) { options[:initializer_path] = i } }
+        },
+        {
+          args: ['-i', '--interval [RESQUE_SCHEDULER_INTERVAL]',
+                 'Interval for checking if a scheduled job must run'],
+          callback: ->(options) { ->(i) { options[:poll_sleep_amount] = i } }
+        },
+        {
+          args: ['-l', '--logfile [LOGFILE]', 'Log file name'],
+          callback: ->(options) { ->(l) { options[:logfile] = l } }
+        },
+        {
+          args: ['-F', '--logformat [LOGFORMAT]', 'Log output format'],
+          callback: ->(options) { ->(f) { options[:logformat] = f } }
+        },
+        {
+          args: ['-P', '--pidfile [PIDFILE]', 'PID file name'],
+          callback: ->(options) { ->(p) { options[:pidfile] = p } }
+        },
+        {
+          args: ['-q', '--quiet', 'Run with minimal output [QUIET]'],
+          callback: ->(options) { ->(q) { options[:quiet] = q } }
+        },
+        {
+          args: ['-v', '--verbose', 'Run with verbose output [VERBOSE]'],
+          callback: ->(options) { ->(v) { options[:verbose] = v } }
+        }
+      ].freeze
+
+      def self.run!(argv = ARGV, env = ENV)
+        new(argv, env).run!
+      end
+
+      def initialize(argv = ARGV, env = ENV)
+        @argv = argv
+        @env = env
+      end
+
+      def run!
+        pre_run
+        run_forever
+      end
+
+      def pre_run
+        parse_options
+        pre_setup
+        setup_env
+      end
+
+      def parse_options
+        option_parser.parse!(argv.dup)
+      end
+
+      def pre_setup
+        if options[:initializer_path]
+          load options[:initializer_path].to_s.strip
+        else
+          false
+        end
+      end
+
+      def setup_env
+        require_relative 'env'
+        runtime_env.setup
+      end
+
+      def run_forever
+        ResqueAdmin::Scheduler.run
+      end
+
+      private
+
+      attr_reader :argv, :env
+
+      def runtime_env
+        @runtime_env ||= ResqueAdmin::Scheduler::Env.new(options)
+      end
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = BANNER
+          opts.version = ResqueAdmin::Scheduler::VERSION
+          OPTIONS.each do |opt|
+            opts.on(*opt[:args], &opt[:callback].call(options))
+          end
+        end
+      end
+
+      def options
+        @options ||= {}.tap do |o|
+          CLI_OPTIONS_ENV_MAPPING.each do |key, envvar|
+            o[key] = env[envvar] if env.include?(envvar)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module Configuration
       # Allows for block-style configuration