resque-admin-scheduler 1.0.2

data/lib/resque/scheduler/lock/base.rb

@@ -0,0 +1,61 @@
+# vim:fileencoding=utf-8
+
+module Resque
+  module Scheduler
+    module Lock
+      class Base
+        attr_reader :key
+        attr_accessor :timeout
+
+        def initialize(key, options = {})
+          @key = key
+
+          # 3 minute default timeout
+          @timeout = options[:timeout] || 60 * 3
+        end
+
+        # Attempts to acquire the lock. Returns true if successfully acquired.
+        def acquire!
+          raise NotImplementedError
+        end
+
+        def value
+          @value ||= [hostname, process_id].join(':')
+        end
+
+        # Returns true if you currently hold the lock.
+        def locked?
+          raise NotImplementedError
+        end
+
+        # Releases the lock.
+        def release!
+          Resque.redis.del(key) == 1
+        end
+
+        # Releases the lock iff we own it
+        def release
+          locked? && release!
+        end
+
+        private
+
+        # Extends the lock by `timeout` seconds.
+        def extend_lock!
+          Resque.redis.expire(key, timeout)
+        end
+
+        def hostname
+          local_hostname = Socket.gethostname
+          Socket.gethostbyname(local_hostname).first
+        rescue
+          local_hostname
+        end
+
+        def process_id
+          Process.pid
+        end
+      end
+    end
+  end
+end

data/lib/resque/scheduler/lock/basic.rb

@@ -0,0 +1,27 @@
+# vim:fileencoding=utf-8
+require_relative 'base'
+
+module Resque
+  module Scheduler
+    module Lock
+      class Basic < Base
+        def acquire!
+          if Resque.redis.setnx(key, value)
+            extend_lock!
+            true
+          end
+        end
+
+        def locked?
+          if Resque.redis.get(key) == value
+            extend_lock!
+
+            return true if Resque.redis.get(key) == value
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/resque/scheduler/lock/resilient.rb

@@ -0,0 +1,78 @@
+# vim:fileencoding=utf-8
+require_relative 'base'
+
+module Resque
+  module Scheduler
+    module Lock
+      class Resilient < Base
+        def acquire!
+          evalsha(:acquire, [key], [value]).to_i == 1
+        end
+
+        def locked?
+          evalsha(:locked, [key], [value]).to_i == 1
+        end
+
+        def timeout=(seconds)
+          if locked?
+            @timeout = seconds
+            @locked_sha = nil
+            @acquire_sha = nil
+          end
+          @timeout
+        end
+
+        private
+
+        def evalsha(script, keys, argv, refresh: false)
+          sha_method_name = "#{script}_sha"
+          Resque.redis.evalsha(
+            send(sha_method_name, refresh),
+            keys: keys,
+            argv: argv
+          )
+        rescue Redis::CommandError => e
+          if e.message =~ /NOSCRIPT/
+            refresh = true
+            retry
+          end
+          raise
+        end
+
+        def locked_sha(refresh = false)
+          @locked_sha = nil if refresh
+
+          @locked_sha ||=
+            Resque.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
+              if redis.call('GET', KEYS[1]) == ARGV[1]
+              then
+                redis.call('EXPIRE', KEYS[1], #{timeout})
+
+                if redis.call('GET', KEYS[1]) == ARGV[1]
+                then
+                  return 1
+                end
+              end
+
+              return 0
+            EOF
+        end
+
+        def acquire_sha(refresh = false)
+          @acquire_sha = nil if refresh
+
+          @acquire_sha ||=
+            Resque.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
+              if redis.call('SETNX', KEYS[1], ARGV[1]) == 1
+              then
+                redis.call('EXPIRE', KEYS[1], #{timeout})
+                return 1
+              else
+                return 0
+              end
+            EOF
+        end
+      end
+    end
+  end
+end

data/lib/resque/scheduler/lock.rb

@@ -0,0 +1,4 @@
+# vim:fileencoding=utf-8
+%w(base basic resilient).each do |file|
+  require "resque/scheduler/lock/#{file}"
+end

data/lib/resque/scheduler/locking.rb

@@ -0,0 +1,104 @@
+# vim:fileencoding=utf-8
+
+# ### Locking the scheduler process
+#
+# There are two places in resque-scheduler that need to be synchonized in order
+# to be able to run redundant scheduler processes while ensuring jobs don't get
+# queued multiple times when the master process changes.
+#
+# 1) Processing the delayed queues (jobs that are created from
+# enqueue_at/enqueue_in, etc) 2) Processing the scheduled (cron-like) jobs from
+# rufus-scheduler
+#
+# Protecting the delayed queues (#1) is relatively easy.  A simple SETNX in
+# redis would suffice.  However, protecting the scheduled jobs is trickier
+# because the clocks on machines could be slightly off or actual firing times
+# could vary slightly due to load.  If scheduler A's clock is slightly ahead of
+# scheduler B's clock (since they are on different machines), when scheduler A
+# dies, we need to ensure that scheduler B doesn't queue jobs that A already
+# queued before it's death. (This all assumes that it is better to miss a few
+# scheduled jobs than it is to run them multiple times for the same iteration.)
+#
+# To avoid queuing multiple jobs in the case of master fail-over, the master
+# should remain the master as long as it can rather than a simple SETNX which
+# would result in the master roll being passed around frequently.
+#
+# Locking Scheme: Each resque-scheduler process attempts to get the master lock
+# via SETNX.  Once obtained, it sets the expiration for 3 minutes
+# (configurable).  The master process continually updates the timeout on the
+# lock key to be 3 minutes in the future in it's loop(s) (see `run`) and when
+# jobs come out of rufus-scheduler (see `load_schedule_job`).  That ensures
+# that a minimum of 3 minutes must pass since the last queuing operation before
+# a new master is chosen.  If, for whatever reason, the master fails to update
+# the expiration for 3 minutes, the key expires and the lock is up for grabs.
+# If miraculously the original master comes back to life, it will realize it is
+# no longer the master and stop processing jobs.
+#
+# The clocks on the scheduler machines can then be up to 3 minutes off from
+# each other without the risk of queueing the same scheduled job twice during a
+# master change.  The catch is, in the event of a master change, no scheduled
+# jobs will be queued during those 3 minutes.  So, there is a trade off: the
+# higher the timeout, the less likely scheduled jobs will be fired twice but
+# greater chances of missing scheduled jobs.  The lower the timeout, less
+# likely jobs will be missed, greater the chances of jobs firing twice.  If you
+# don't care about jobs firing twice or are certain your machines' clocks are
+# well in sync, a lower timeout is preferable.  One thing to keep in mind: this
+# only effects *scheduled* jobs - delayed jobs will never be lost or skipped
+# since eventually a master will come online and it will process everything
+# that is ready (no matter how old it is).  Scheduled jobs work like cron - if
+# you stop cron, no jobs fire while it's stopped and it doesn't fire jobs that
+# were missed when it starts up again.
+
+require_relative 'lock'
+
+module Resque
+  module Scheduler
+    module Locking
+      def master_lock
+        @master_lock ||= build_master_lock
+      end
+
+      def supports_lua?
+        redis_master_version >= 2.5
+      end
+
+      def master?
+        master_lock.acquire! || master_lock.locked?
+      end
+
+      def release_master_lock!
+        warn "#{self}\#release_master_lock! is deprecated because it does " \
+             "not respect lock ownership. Use #{self}\#release_master_lock " \
+             "instead (at #{caller.first}"
+
+        master_lock.release!
+      end
+
+      def release_master_lock
+        master_lock.release
+      rescue Errno::EAGAIN, Errno::ECONNRESET, Redis::CannotConnectError
+        @master_lock = nil
+      end
+
+      private
+
+      def build_master_lock
+        if supports_lua?
+          Resque::Scheduler::Lock::Resilient.new(master_lock_key)
+        else
+          Resque::Scheduler::Lock::Basic.new(master_lock_key)
+        end
+      end
+
+      def master_lock_key
+        lock_prefix = ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] || ''
+        lock_prefix += ':' if lock_prefix != ''
+        "#{Resque.redis.namespace}:#{lock_prefix}resque_scheduler_master_lock"
+      end
+
+      def redis_master_version
+        Resque.redis.info['redis_version'].to_f
+      end
+    end
+  end
+end

data/lib/resque/scheduler/logger_builder.rb

@@ -0,0 +1,72 @@
+# vim:fileencoding=utf-8
+
+require 'mono_logger'
+
+module Resque
+  module Scheduler
+    # Just builds a logger, with specified verbosity and destination.
+    # The simplest example:
+    #
+    #   Resque::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.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-scheduler: [#{severity}] #{datetime.iso8601}: #{msg}\n"
+        end
+      end
+
+      def json_formatter
+        proc do |severity, datetime, progname, msg|
+          require 'json'
+          JSON.dump(
+            name: 'resque-scheduler',
+            progname: progname,
+            level: severity,
+            timestamp: datetime.iso8601,
+            msg: msg
+          ) + "\n"
+        end
+      end
+    end
+  end
+end

data/lib/resque/scheduler/plugin.rb

@@ -0,0 +1,31 @@
+# vim:fileencoding=utf-8
+
+module Resque
+  module Scheduler
+    module Plugin
+      def self.hooks(job, pattern)
+        job.methods.grep(/^#{pattern}/).sort
+      end
+
+      def self.run_hooks(job, pattern, *args)
+        results = hooks(job, pattern).map do |hook|
+          job.send(hook, *args)
+        end
+
+        results.all? { |result| result != false }
+      end
+
+      def self.run_before_delayed_enqueue_hooks(klass, *args)
+        run_hooks(klass, 'before_delayed_enqueue', *args)
+      end
+
+      def self.run_before_schedule_hooks(klass, *args)
+        run_hooks(klass, 'before_schedule', *args)
+      end
+
+      def self.run_after_schedule_hooks(klass, *args)
+        run_hooks(klass, 'after_schedule', *args)
+      end
+    end
+  end
+end

data/lib/resque/scheduler/scheduling_extensions.rb

@@ -0,0 +1,141 @@
+# vim:fileencoding=utf-8
+
+module Resque
+  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 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's 'every'
+      # usage for valid syntax. If :cron is present it will take precedence
+      # over :every.
+      #
+      # :class must be a resque 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.
+      #
+      #    Resque.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/server/views/delayed.erb

@@ -0,0 +1,63 @@
+<h1>Delayed Jobs</h1>
+<%- size = resque.delayed_queue_schedule_size %>
+
+<%= scheduler_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.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.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="<%= 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/server/views/delayed_schedules.erb

@@ -0,0 +1,20 @@
+<h1>Delayed jobs scheduled for <%= params[:klass] %> (<%= show_job_arguments(@args) %>)</h1>
+
+<table class='jobs'>
+<tr>
+  <th>Timestamp</th>
+</tr>
+
+<% @timestamps.each do |t| %>
+<tr>
+  <td>
+    <%= Time.at(t) %>
+  </td>
+</tr>
+<% end %>
+<% if @timestamps.empty? %>
+  <tr>
+    <td class='no-data'>There are no such jobs scheduled.</td>
+  </tr>
+<% end %>
+</table>

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 show_job_arguments(job['args']) %></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/requeue-params.erb

@@ -0,0 +1,23 @@
+<h1><%= @job_name %></h1>
+
+<p class='intro'>
+   This job requires parameters:
+</p>
+
+<form style="float:left" action="<%= u "/schedule/requeue_with_params" %>" method="post">
+  <table>
+  <% @parameters.each do |key, value| %>
+  <% value ||= {} %>
+    <tr>
+      <td>
+        <%= key %>
+        <% if value['description'] || value[:description] %>
+          <span style="border-bottom:1px dotted;" title="<%=value ['description'] || value[:description] %>">(?)</span>
+        <% end %>:
+      </td>
+      <td><input type="text" name="<%= key %>" value="<%= value['default'] || value[:default] %>"></td>
+  <% end %>
+  </table>
+  <input type="hidden" name="job_name" value="<%= @job_name %>">
+  <input type="submit" value="Queue now">
+</form>