istox-resque-scheduler 1.0.0.pre

data/lib/resque/scheduler/env.rb

@@ -0,0 +1,89 @@
+# vim:fileencoding=utf-8
+
+require 'English' # $PROCESS_ID
+
+module Resque
+  module Scheduler
+    class Env
+      def initialize(options)
+        @options = options
+        @pidfile_path = nil
+      end
+
+      def setup
+        require 'resque'
+        require 'resque/scheduler'
+
+        setup_backgrounding
+        setup_pid_file
+        setup_scheduler_configuration
+      end
+
+      def cleanup
+        cleanup_pid_file
+      end
+
+      private
+
+      attr_reader :options, :pidfile_path
+
+      def setup_backgrounding
+        return unless options[:background]
+
+        # Need to set this here for conditional Process.daemon redirect of
+        # stderr/stdout to /dev/null
+        Resque::Scheduler.quiet = if options.key?(:quiet)
+                                    !!options[:quiet]
+                                  else
+                                    true
+                                  end
+
+        unless Process.respond_to?('daemon')
+          abort 'background option is set, which requires ruby >= 1.9'
+        end
+
+        Process.daemon(true, !Resque::Scheduler.quiet)
+        Resque.redis._client.reconnect
+      end
+
+      def setup_pid_file
+        return unless options[:pidfile]
+
+        @pidfile_path = File.expand_path(options[:pidfile])
+
+        File.open(pidfile_path, 'w') do |f|
+          f.puts $PROCESS_ID
+        end
+
+        at_exit { cleanup_pid_file }
+      end
+
+      def setup_scheduler_configuration
+        Resque::Scheduler.configure do |c|
+          c.app_name = options[:app_name] if options.key?(:app_name)
+
+          c.dynamic = !!options[:dynamic] if options.key?(:dynamic)
+
+          c.env = options[:env] if options.key?(:env)
+
+          c.logfile = options[:logfile] if options.key?(:logfile)
+
+          c.logformat = options[:logformat] if options.key?(:logformat)
+
+          if (psleep = options[:poll_sleep_amount]) && !psleep.nil?
+            c.poll_sleep_amount = Float(psleep)
+          end
+
+          c.verbose = !!options[:verbose] if options.key?(:verbose)
+        end
+      end
+
+      def cleanup_pid_file
+        return unless pidfile_path
+
+        File.delete(pidfile_path) if File.exist?(pidfile_path)
+        @pidfile_path = nil
+      end
+    end
+  end
+end

data/lib/resque/scheduler/extension.rb

@@ -0,0 +1,13 @@
+# vim:fileencoding=utf-8
+
+require_relative 'scheduling_extensions'
+require_relative 'delaying_extensions'
+
+module Resque
+  module Scheduler
+    module Extension
+      include SchedulingExtensions
+      include DelayingExtensions
+    end
+  end
+end

data/lib/resque/scheduler/failure_handler.rb

@@ -0,0 +1,11 @@
+module Resque
+  module Scheduler
+    class FailureHandler
+      def self.on_enqueue_failure(_, e)
+        Resque::Scheduler.log_error(
+          "#{e.class.name}: #{e.message} #{e.backtrace.inspect}"
+        )
+      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/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
+
+          # 10 seconds default timeout
+          @timeout = options[:timeout] || 10
+        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.data_store.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.data_store.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/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 *INTERMITTENT_ERRORS
+        @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.data_store.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