resque-scheduler 2.0.0 → 2.3.1

data/lib/resque/scheduler.rb

@@ -1,11 +1,12 @@
 require 'rufus/scheduler'
-require 'thwait'
+require 'resque/scheduler_locking'
+require 'resque_scheduler/logger_builder'
 
 module Resque
 
   class Scheduler
 
-    extend Resque::Helpers
+    extend Resque::SchedulerLocking
 
     class << self
 
@@ -15,13 +16,18 @@ module Resque
       # If set, produces no output
       attr_accessor :mute
 
-      # If set, will try to update the schulde in the loop
+      # If set, will write messages to the file
+      attr_accessor :logfile
+
+      # If set, will try to update the schedule in the loop
       attr_accessor :dynamic
 
       # Amount of time in seconds to sleep between polls of the delayed
       # queue.  Defaults to 5
       attr_writer :poll_sleep_amount
 
+      attr_writer :logger
+
       # the Rufus::Scheduler jobs that are scheduled
       def scheduled_jobs
         @@scheduled_jobs
@@ -31,12 +37,23 @@ module Resque
         @poll_sleep_amount ||= 5 # seconds
       end
 
+      def logger
+        @logger ||= ResqueScheduler::LoggerBuilder.new(:mute => mute, :verbose => verbose, :log_dev => logfile).build
+      end
+
       # Schedule all jobs and continually look for delayed jobs (never returns)
       def run
         $0 = "resque-scheduler: Starting"
+
         # trap signals
         register_signal_handlers
 
+        # Quote from the resque/worker.
+        # Fix buffering so we can `rake resque:scheduler > scheduler.log` and
+        # get output from the child in there.
+        $stdout.sync = true
+        $stderr.sync = true
+
         # Load the schedule into rufus
         # If dynamic is set, load that schedule otherwise use normal load
         if dynamic
@@ -47,11 +64,13 @@ module Resque
 
         # Now start the scheduling part of the loop.
         loop do
-          begin
-            handle_delayed_items
-            update_schedule if dynamic
-          rescue Errno::EAGAIN, Errno::ECONNRESET => e
-            warn e.message
+          if is_master?
+            begin
+              handle_delayed_items
+              update_schedule if dynamic
+            rescue Errno::EAGAIN, Errno::ECONNRESET => e
+              warn e.message
+            end
           end
           poll_sleep
         end
@@ -59,6 +78,7 @@ module Resque
         # 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.
@@ -133,8 +153,10 @@ module Resque
             if !config[interval_type].nil? && config[interval_type].length > 0
               args = optionizate_interval_value(config[interval_type])
               @@scheduled_jobs[name] = rufus_scheduler.send(interval_type, *args) do
-                log! "queueing #{config['class']} (#{name})"
-                handle_errors { enqueue_from_config(config) }
+                if is_master?
+                  log! "queueing #{config['class']} (#{name})"
+                  handle_errors { enqueue_from_config(config) }
+                end
               end
               interval_defined = true
               break
@@ -169,7 +191,8 @@ module Resque
         item = nil
         begin
           handle_shutdown do
-            if item = Resque.next_item_for_timestamp(timestamp)
+            # Continually check that it is still the master
+            if is_master? && item = Resque.next_item_for_timestamp(timestamp)
               log "queuing #{item['class']} [delayed]"
               handle_errors { enqueue_from_config(item) }
             end
@@ -197,7 +220,7 @@ module Resque
         args = job_config['args'] || job_config[:args]
 
         klass_name = job_config['class'] || job_config[:class]
-        klass = constantize(klass_name) rescue klass_name
+        klass = ResqueScheduler::Util.constantize(klass_name) rescue klass_name
 
         params = args.is_a?(Hash) ? [args] : Array(args)
         queue = job_config['queue'] || job_config[:queue] || Resque.queue_from_class(klass)
@@ -207,7 +230,7 @@ module Resque
           # job class can not be constantized (via a requeue call from the web perhaps), fall
           # back to enqueing normally via Resque::Job.create.
           begin
-            constantize(job_klass).scheduled(queue, klass_name, *params)
+            ResqueScheduler::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)
@@ -218,7 +241,14 @@ module Resque
           # one app that schedules for another
           if Class === klass
             ResqueScheduler::Plugin.run_before_delayed_enqueue_hooks(klass, *params)
-            Resque.enqueue_to(queue, 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.
+            if klass.respond_to?(:scheduled)
+              klass.scheduled(queue, klass_name, *params)
+            else
+              Resque.enqueue_to(queue, klass, *params)
+            end
           else
             # This will not run the before_hooks in rescue, but will at least
             # queue the job.
@@ -278,19 +308,26 @@ module Resque
         true
       end
 
-      # Sets the shutdown flag, exits if sleeping
+      # Sets the shutdown flag, clean schedules and exits if sleeping
       def shutdown
         @shutdown = true
-        exit if @sleeping
+
+        if @sleeping
+          thread = Thread.new do
+            Resque.clean_schedules
+            release_master_lock!
+          end
+          thread.join
+          exit
+        end
       end
 
       def log!(msg)
-        puts "#{Time.now.strftime("%Y-%m-%d %H:%M:%S")} #{msg}" unless mute
+        logger.info msg
       end
 
       def log(msg)
-        # add "verbose" logic later
-        log!(msg) if verbose
+        logger.debug msg
       end
 
       def procline(string)

data/lib/resque/scheduler_locking.rb

@@ -0,0 +1,89 @@
+# ### 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 'resque/scheduler/lock'
+
+module Resque
+  module SchedulerLocking
+    def master_lock
+      @master_lock ||= build_master_lock
+    end
+
+    def supports_lua?
+      redis_master_version >= 2.5
+    end
+
+    def is_master?
+      master_lock.acquire! || master_lock.locked?
+    end
+
+    def release_master_lock!
+      master_lock.release!
+    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
+      "#{ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] || ''}resque_scheduler_master_lock".to_sym
+    end
+
+    def redis_master_version
+      Resque.redis.info['redis_version'].to_f
+    end
+  end
+end

data/lib/resque_scheduler/logger_builder.rb

@@ -0,0 +1,51 @@
+module ResqueScheduler
+  # Just builds a logger, with specified verbosity and destination.
+  # The simplest example:
+  #
+  #   ResqueScheduler::LoggerBuilder.new.build
+  class LoggerBuilder
+    # Initializes new instance of the builder
+    #
+    # Pass :opts Hash with
+    #   - :mute 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
+    #
+    # Example:
+    #
+    #   LoggerBuilder.new(:mute => false, :verbose => true, :log_dev => 'log/sheduler.log')
+    def initialize(opts={})
+      @muted   = !!opts[:mute]
+      @verbose = !!opts[:verbose]
+      @log_dev = opts[:log_dev] || STDOUT
+    end
+
+    # Returns an instance of Logger
+    def build
+      logger = Logger.new(@log_dev)
+      logger.level = level
+      logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+      logger.formatter = formatter
+
+      logger
+    end
+
+    private
+
+    def level
+      if @verbose && !@muted
+        Logger::DEBUG
+      elsif !@muted
+        Logger::INFO
+      else
+        Logger::FATAL
+      end
+    end
+
+    def formatter
+      proc do |severity, datetime, progname, msg|
+        "[#{severity}] #{datetime}: #{msg}\n"
+      end
+    end
+  end
+end

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

@@ -8,6 +8,7 @@
 
 <p class='intro'>
   This list below contains the timestamps for scheduled delayed jobs.
+  Server local time: <%= Time.now %>
 </p>
 
 <p class='sub'>
@@ -45,4 +46,4 @@
   <% end %>
 </table>
 
-<%= partial :next_more, :start => start, :size => size %>
+<%= 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>

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

@@ -3,6 +3,7 @@
 <p class='intro'>
   The list below contains all scheduled jobs.  Click &quot;Queue now&quot; to queue
   a job immediately.
+  Server local time: <%= Time.now %>
 </p>
 
 <table>
@@ -26,10 +27,10 @@
       </td>
       <td><%= h name %></td>
       <td><%= h config['description'] %></td>
-      <td style="white-space:nowrap"><%= if !config['every'].nil? 
-                                           h('every: ' + config['every'])
+      <td style="white-space:nowrap"><%= if !config['every'].nil?
+                                           h('every: ' + (config['every'].is_a?(Array) ? config['every'].join(", ") : config['every'].to_s ))
                                          elsif !config['cron'].nil?
-                                           h('cron: ' + config['cron']) 
+                                           h('cron: ' + config['cron'].to_s)
                                          else
                                            'Not currently scheduled'
                                          end %></td>

data/lib/resque_scheduler/server.rb

@@ -1,6 +1,5 @@
 require 'resque_scheduler'
 require 'resque/server'
-
 # Extend Resque::Server to add tabs
 module ResqueScheduler
 
@@ -16,7 +15,7 @@ module ResqueScheduler
           end
 
           def queue_from_class_name(class_name)
-            Resque.queue_from_class(Resque.constantize(class_name))
+            Resque.queue_from_class(ResqueScheduler::Util.constantize(class_name))
           end
         end
 
@@ -27,7 +26,30 @@ module ResqueScheduler
         end
 
         post "/schedule/requeue" do
-          config = Resque.schedule[params['job_name']]
+          @job_name = params['job_name'] || params[:job_name]
+          config = Resque.schedule[@job_name]
+          @parameters = config['parameters'] || config[:parameters]
+          if @parameters
+            erb File.read(File.join(File.dirname(__FILE__), 'server/views/requeue-params.erb'))
+          else
+            Resque::Scheduler.enqueue_from_config(config)
+            redirect u("/overview")
+          end
+        end
+
+        post "/schedule/requeue_with_params" do
+          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 {|key, value| key == 'job_name' || key == :job_name}
+
+          # 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

data/lib/resque_scheduler/tasks.rb

@@ -9,17 +9,23 @@ namespace :resque do
     require 'resque'
     require 'resque_scheduler'
 
+    # Need to set this here for conditional Process.daemon redirect of stderr/stdout to /dev/null
+    Resque::Scheduler.mute = true if ENV['MUTE']
+
     if ENV['BACKGROUND']
       unless Process.respond_to?('daemon')
         abort "env var BACKGROUND is set, which requires ruby >= 1.9"
       end
-      Process.daemon(true)
+      Process.daemon(true, !Resque::Scheduler.mute)
+      Resque.redis.client.reconnect
     end
 
     File.open(ENV['PIDFILE'], 'w') { |f| f << Process.pid.to_s } if ENV['PIDFILE']
 
-    Resque::Scheduler.dynamic = true if ENV['DYNAMIC_SCHEDULE']
-    Resque::Scheduler.verbose = true if ENV['VERBOSE']
+    Resque::Scheduler.dynamic           = true if ENV['DYNAMIC_SCHEDULE']
+    Resque::Scheduler.verbose           = true if ENV['VERBOSE']
+    Resque::Scheduler.logfile           = ENV['LOGFILE'] if ENV['LOGFILE']
+    Resque::Scheduler.poll_sleep_amount = Float(ENV['RESQUE_SCHEDULER_INTERVAL']) if ENV['RESQUE_SCHEDULER_INTERVAL']
     Resque::Scheduler.run
   end
 

data/lib/resque_scheduler/util.rb

@@ -0,0 +1,34 @@
+module ResqueScheduler
+  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 { |part| part[0] = part[0].chr.upcase }.join
+    end
+  end
+end

data/lib/resque_scheduler/version.rb

@@ -1,3 +1,5 @@
+# vim:fileencoding=utf-8
+
 module ResqueScheduler
-  VERSION = '2.0.0'
+  VERSION = '2.3.1'
 end