resque-scheduler 2.5.5 → 3.0.0

data/lib/resque_scheduler/cli.rb

@@ -1,160 +0,0 @@
-# vim:fileencoding=utf-8
-
-require 'optparse'
-
-module ResqueScheduler
-  class Cli
-    BANNER = <<-EOF.gsub(/ {6}/, '')
-      Usage: resque-scheduler [options]
-
-      Runs a resque 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] (or [MUTE])'],
-        callback: ->(options) { ->(q) { options[:mute] = 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
-      OptionParser.new do |opts|
-        opts.banner = BANNER
-        OPTIONS.each do |opt|
-          opts.on(*opt[:args], &(opt[:callback].call(options)))
-        end
-      end.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 'resque'
-      require 'resque/scheduler'
-
-      # Need to set this here for conditional Process.daemon redirect of
-      # stderr/stdout to /dev/null
-      Resque::Scheduler.mute = !!options[:mute]
-
-      if options[:background]
-        unless Process.respond_to?('daemon')
-          abort 'background option is set, which requires ruby >= 1.9'
-        end
-
-        Process.daemon(true, !Resque::Scheduler.mute)
-        Resque.redis.client.reconnect
-      end
-
-      File.open(options[:pidfile], 'w') do |f|
-        f.puts $PROCESS_ID
-      end if options[:pidfile]
-
-      Resque::Scheduler.configure do |c|
-        # These settings are somewhat redundant given the defaults present
-        # in the attr reader methods.  They are left here for clarity and
-        # to serve as an example of how to use `.configure`.
-
-        c.app_name = options[:app_name]
-        c.dynamic = !!options[:dynamic]
-        c.env = options[:env]
-        c.logfile = options[:logfile]
-        c.logformat = options[:logformat]
-        c.poll_sleep_amount = Float(options[:poll_sleep_amount] || '5')
-        c.verbose = !!options[:verbose]
-      end
-    end
-
-    def run_forever
-      Resque::Scheduler.run
-    end
-
-    private
-
-    attr_reader :argv, :env
-
-    def options
-      @options ||= {
-        app_name: env['APP_NAME'],
-        background: env['BACKGROUND'],
-        dynamic: env['DYNAMIC_SCHEDULE'],
-        env: env['RAILS_ENV'],
-        initializer_path: env['INITIALIZER_PATH'],
-        logfile: env['LOGFILE'],
-        logformat: env['LOGFORMAT'],
-        mute: env['MUTE'] || env['QUIET'],
-        pidfile: env['PIDFILE'],
-        poll_sleep_amount: env['RESQUE_SCHEDULER_INTERVAL'],
-        verbose: env['VERBOSE']
-      }
-    end
-  end
-end

data/lib/resque_scheduler/logger_builder.rb

@@ -1,72 +0,0 @@
-# vim:fileencoding=utf-8
-
-require 'mono_logger'
-
-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
-    #   - :format log format, either 'text' or 'json'. Default - 'text'
-    #
-    # Example:
-    #
-    #   LoggerBuilder.new(
-    #     :mute => false, :verbose => true, :log_dev => 'log/scheduler.log'
-    #   )
-    def initialize(opts={})
-      @muted = !!opts[:mute]
-      @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 && !@muted
-        MonoLogger::DEBUG
-      elsif !@muted
-        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

data/lib/resque_scheduler/plugin.rb

@@ -1,28 +0,0 @@
-module ResqueScheduler
-  module Plugin
-    extend self
-    def hooks(job, pattern)
-      job.methods.grep(/^#{pattern}/).sort
-    end
-
-    def run_hooks(job, pattern, *args)
-      results = hooks(job, pattern).collect do |hook|
-        job.send(hook, *args)
-      end
-
-      results.all? { |result| result != false }
-    end
-
-    def run_before_delayed_enqueue_hooks(klass, *args)
-      run_hooks(klass, 'before_delayed_enqueue', *args)
-    end
-
-    def run_before_schedule_hooks(klass, *args)
-      run_hooks(klass, 'before_schedule', *args)
-    end
-
-    def run_after_schedule_hooks(klass, *args)
-      run_hooks(klass, 'after_schedule', *args)
-    end
-  end
-end

data/lib/resque_scheduler/server.rb

@@ -1,183 +0,0 @@
-require 'resque_scheduler'
-require 'resque/server'
-require 'json'
-
-# Extend Resque::Server to add tabs
-module ResqueScheduler
-  module Server
-    def self.included(base)
-      base.class_eval do
-        helpers do
-          def format_time(t)
-            t.strftime('%Y-%m-%d %H:%M:%S %z')
-          end
-
-          def queue_from_class_name(class_name)
-            Resque.queue_from_class(ResqueScheduler::Util.constantize(class_name))
-          end
-
-          def find_job(worker)
-            worker = worker.downcase
-            results = Array.new
-
-            # Check working jobs
-            working = Resque.working
-            working = [working] unless working.is_a?(Array)
-            work = working.select do |w|
-              w.job && w.job["payload"] && w.job['payload']['class'].downcase.include?(worker)
-            end
-            work.each do |w|
-              results += [w.job['payload'].merge({'queue' => w.job['queue'], 'where_at' => 'working'})]
-            end
-
-            # Check delayed Jobs
-            dels = Array.new
-            Resque.delayed_queue_peek(0, Resque.delayed_queue_schedule_size).each do |d|
-              Resque.delayed_timestamp_peek(d, 0, Resque.delayed_timestamp_size(d)).each do |j|
-                dels << j.merge!({'timestamp' => d})
-              end
-            end
-            results += dels.select do |j|
-              j['class'].downcase.include?(worker) && j.merge!({'where_at' => 'delayed'})
-            end
-
-            # Check Queues
-            Resque.queues.each do |queue|
-                queued = Resque.peek(queue, 0, Resque.size(queue))
-                queued = [queued] unless queued.is_a?(Array)
-                results += queued.select do |j|
-                  j['class'].downcase.include?(worker) && j.merge!({'queue' => queue, 'where_at' => 'queued'})
-                end
-            end
-            results
-          end
-
-          def schedule_interval(config)
-            if config['every']
-              schedule_interval_every(config['every'])
-            elsif config['cron']
-              'cron: ' + config['cron'].to_s
-            else
-              'Not currently scheduled'
-            end
-          end
-
-          def schedule_interval_every(every)
-            every = [*every]
-            s = 'every: ' << every.first
-
-            return s unless every.length > 1
-
-            s << ' ('
-            meta = every.last.map do |key, value|
-              "#{key.to_s.gsub(/_/, ' ')} #{value}"
-            end
-            s << meta.join(', ') << ')'
-          end
-
-          def schedule_class(config)
-            if config['class'].nil? && !config['custom_job_class'].nil?
-              config['custom_job_class']
-            else
-              config['class']
-            end
-          end
-
-          def scheduled_in_this_env?(name)
-            return true if Resque.schedule[name]['rails_env'].nil?
-            Resque.schedule[name]['rails_env'] == Resque::Scheduler.env
-          end
-        end
-
-        get "/schedule" do
-          Resque.reload_schedule! if Resque::Scheduler.dynamic
-          # Is there a better way to specify alternate template locations with sinatra?
-          erb File.read(File.join(File.dirname(__FILE__), 'server/views/scheduler.erb'))
-        end
-
-        post "/schedule/requeue" do
-          @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
-
-        get "/delayed" do
-          # Is there a better way to specify alternate template locations with sinatra?
-          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed.erb'))
-        end
-
-        get "/delayed/jobs/:klass" do
-          begin
-            klass = ResqueScheduler::Util::constantize(params[:klass])
-            @args = JSON.load(URI.decode(params[:args]))
-            @timestamps = Resque.scheduled_at(klass, *@args)
-          rescue => err
-            @timestamps = []
-          end
-
-          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed_schedules.erb'))
-        end
-
-        post "/delayed/search" do
-          # Is there a better way to specify alternate template locations with sinatra?
-          @jobs = find_job(params[:search])
-          erb File.read(File.join(File.dirname(__FILE__), 'server/views/search.erb'))
-        end
-
-        get "/delayed/:timestamp" do
-          # Is there a better way to specify alternate template locations with sinatra?
-          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed_timestamp.erb'))
-        end
-
-        post "/delayed/queue_now" do
-          timestamp = params['timestamp']
-          Resque::Scheduler.enqueue_delayed_items_for_timestamp(timestamp.to_i) if timestamp.to_i > 0
-          redirect u("/overview")
-        end
-
-        post "/delayed/cancel_now" do
-          klass = ResqueScheduler::Util.constantize params['klass']
-          timestamp = params['timestamp']
-          args = Resque.decode params['args']
-          Resque.remove_delayed_job_from_timestamp(timestamp, klass, *args)
-          redirect u("/delayed")
-        end
-
-        post "/delayed/clear" do
-          Resque.reset_delayed_queue
-          redirect u('delayed')
-        end
-      end
-    end
-  end
-end
-
-Resque::Server.tabs << 'Schedule'
-Resque::Server.tabs << 'Delayed'
-
-Resque::Server.class_eval do
-  include ResqueScheduler::Server
-end

data/lib/resque_scheduler/util.rb

@@ -1,34 +0,0 @@
-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