resque_admin-scheduler 1.0.4 → 1.0.5

data/lib/resque_admin/scheduler/env.rb

@@ -1,89 +0,0 @@
-# vim:fileencoding=utf-8
-
-require 'English' # $PROCESS_ID
-
-module ResqueAdmin
-  module Scheduler
-    class Env
-      def initialize(options)
-        @options = options
-        @pidfile_path = nil
-      end
-
-      def setup
-        require 'resque'
-        require 'resque_admin/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
-        ResqueAdmin::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, !ResqueAdmin::Scheduler.quiet)
-        ResqueAdmin.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
-        ResqueAdmin::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_admin/scheduler/extension.rb

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

data/lib/resque_admin/scheduler/failure_handler.rb

@@ -1,11 +0,0 @@
-module ResqueAdmin
-  module Scheduler
-    class FailureHandler
-      def self.on_enqueue_failure(_, e)
-        ResqueAdmin::Scheduler.log_error(
-          "#{e.class.name}: #{e.message} #{e.backtrace.inspect}"
-        )
-      end
-    end
-  end
-end

data/lib/resque_admin/scheduler/lock.rb

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

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

@@ -1,61 +0,0 @@
-# vim:fileencoding=utf-8
-
-module ResqueAdmin
-  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!
-          ResqueAdmin.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!
-          ResqueAdmin.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_admin/scheduler/lock/basic.rb

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

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

@@ -1,78 +0,0 @@
-# vim:fileencoding=utf-8
-require_relative 'base'
-
-module ResqueAdmin
-  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"
-          ResqueAdmin.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 ||=
-            ResqueAdmin.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 ||=
-            ResqueAdmin.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_admin/scheduler/locking.rb

@@ -1,104 +0,0 @@
-# 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 ResqueAdmin
-  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?
-          ResqueAdmin::Scheduler::Lock::Resilient.new(master_lock_key)
-        else
-          ResqueAdmin::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 != ''
-        "#{ResqueAdmin.redis.namespace}:#{lock_prefix}resque_scheduler_master_lock"
-      end
-
-      def redis_master_version
-        ResqueAdmin.redis.info['redis_version'].to_f
-      end
-    end
-  end
-end

data/lib/resque_admin/scheduler/logger_builder.rb

@@ -1,72 +0,0 @@
-# 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.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