resque_admin-scheduler 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83fb3060f37567bbac36efc8d64683923baf1b70
-  data.tar.gz: 01c979171925bc30bf9b8da0382be4475c05af57
+  metadata.gz: b9d942201a18e355765e7215ec4421c1439d5562
+  data.tar.gz: 5256fe4e2f72e0112f151bb37a6b7d90ec12633c
 SHA512:
-  metadata.gz: 526b7495929677d616da2b911a077d29bad088bbc1f53e87764e506e50c17ccbbd3f19c8cd7abc04f7057d8aa5867195a5a8dbe1f0c3591a6e066f344791f525
-  data.tar.gz: 0a94955015dd3b188659c81ccac304690741ae2516fa72dd7829c15c745f520de0f791dcaa98ddae522552e4946a036901a7d0df4fead3d8aceabc824cd786a6
+  metadata.gz: 109e664aad594f9b3354c37f139b0df2d11b7aed24394f7bc957c6f93619e89ea926fd747c5028a13bbefaea7ad69c0e6c454c56d2e16c53484873b9c737eebf
+  data.tar.gz: 3896b74f034bb34754bbc4d27cadfb8c28047c54bc0b7fc4310c71a959e31542d080ff8db20eaa9fc7174879a391c57a49887f7ac341a1efbc51d1aafe4ddc97

data/bin/migrate_to_timestamps_set.rb

@@ -1,15 +1,15 @@
 # vim:fileencoding=utf-8
 
 require 'redis'
-require 'resque'
+require 'resque-admin'
 
 if ARGV.size != 1
   puts 'migrate_to_timestamps_set.rb <redis-host:redis-port>'
   exit
 end
 
-Resque.redis = ARGV[0]
-redis = Resque.redis
+ResqueAdmin.redis = ARGV[0]
+redis = ResqueAdmin.redis
 Array(redis.keys('delayed:*')).each do |key|
   jobs = redis.lrange(key, 0, -1)
   jobs.each { |job| redis.sadd("timestamps:#{job}", key) }

data/exe/resque-scheduler

@@ -2,4 +2,4 @@
 # vim:fileencoding=utf-8
 
 require 'resque-scheduler'
-Resque::Scheduler::Cli.run!
+ResqueAdmin::Scheduler::Cli.run!

data/lib/{resque → resque-admin}/scheduler.rb

@@ -7,18 +7,18 @@ require_relative 'scheduler/logger_builder'
 require_relative 'scheduler/signal_handling'
 require_relative 'scheduler/failure_handler'
 
-module Resque
+module ResqueAdmin
   module Scheduler
-    autoload :Cli, 'resque/scheduler/cli'
-    autoload :Extension, 'resque/scheduler/extension'
-    autoload :Util, 'resque/scheduler/util'
-    autoload :VERSION, 'resque/scheduler/version'
+    autoload :Cli, 'resque-admin/scheduler/cli'
+    autoload :Extension, 'resque-admin/scheduler/extension'
+    autoload :Util, 'resque-admin/scheduler/util'
+    autoload :VERSION, 'resque-admin/scheduler/version'
 
     private
 
-    extend Resque::Scheduler::Locking
-    extend Resque::Scheduler::Configuration
-    extend Resque::Scheduler::SignalHandling
+    extend ResqueAdmin::Scheduler::Locking
+    extend ResqueAdmin::Scheduler::Configuration
+    extend ResqueAdmin::Scheduler::SignalHandling
 
     public
 
@@ -84,22 +84,22 @@ module Resque
         end
       end
 
-      # Pulls the schedule from Resque.schedule and loads it into the
+      # Pulls the schedule from ResqueAdmin.schedule and loads it into the
       # rufus scheduler instance
       def load_schedule!
         procline 'Loading Schedule'
 
         # Need to load the schedule from redis for the first time if dynamic
-        Resque.reload_schedule! if dynamic
+        ResqueAdmin.reload_schedule! if dynamic
 
-        log! 'Schedule empty! Set Resque.schedule' if Resque.schedule.empty?
+        log! 'Schedule empty! Set ResqueAdmin.schedule' if ResqueAdmin.schedule.empty?
 
         @scheduled_jobs = {}
 
-        Resque.schedule.each do |name, config|
+        ResqueAdmin.schedule.each do |name, config|
           load_schedule_job(name, config)
         end
-        Resque.redis.del(:schedules_changed)
+        ResqueAdmin.redis.del(:schedules_changed)
         procline 'Schedules Loaded'
       end
 
@@ -125,9 +125,9 @@ module Resque
       # in @scheduled_jobs
       def load_schedule_job(name, config)
         # If `rails_env` or `env` is set in the config, load jobs only if they
-        # are meant to be loaded in `Resque::Scheduler.env`.  If `rails_env` or
+        # are meant to be loaded in `ResqueAdmin::Scheduler.env`.  If `rails_env` or
         # `env` is missing, the job should be scheduled regardless of the value
-        # of `Resque::Scheduler.env`.
+        # of `ResqueAdmin::Scheduler.env`.
 
         configured_env = config['rails_env'] || config['env']
 
@@ -160,8 +160,8 @@ module Resque
 
       # Returns true if the given schedule config hash matches the current env
       def rails_env_matches?(config)
-        warn '`Resque::Scheduler.rails_env_matches?` is deprecated. ' \
-             'Please use `Resque::Scheduler.env_matches?` instead.'
+        warn '`ResqueAdmin::Scheduler.rails_env_matches?` is deprecated. ' \
+             'Please use `ResqueAdmin::Scheduler.env_matches?` instead.'
         config['rails_env'] && env &&
           config['rails_env'].split(/[\s,]+/).include?(env)
       end
@@ -175,18 +175,18 @@ module Resque
       # Handles queueing delayed items
       # at_time - Time to start scheduling items (default: now).
       def handle_delayed_items(at_time = nil)
-        timestamp = Resque.next_delayed_timestamp(at_time)
+        timestamp = ResqueAdmin.next_delayed_timestamp(at_time)
         if timestamp
           procline 'Processing Delayed Items'
           until timestamp.nil?
             enqueue_delayed_items_for_timestamp(timestamp)
-            timestamp = Resque.next_delayed_timestamp(at_time)
+            timestamp = ResqueAdmin.next_delayed_timestamp(at_time)
           end
         end
       end
 
       def enqueue_next_item(timestamp)
-        item = Resque.next_item_for_timestamp(timestamp)
+        item = ResqueAdmin.next_item_for_timestamp(timestamp)
 
         if item
           log "queuing #{item['class']} [delayed]"
@@ -213,7 +213,7 @@ module Resque
       def enqueue(config)
         enqueue_from_config(config)
       rescue => e
-        Resque::Scheduler.failure_handler.on_enqueue_failure(config, e)
+        ResqueAdmin::Scheduler.failure_handler.on_enqueue_failure(config, e)
       end
 
       def handle_shutdown
@@ -228,7 +228,7 @@ module Resque
 
         klass_name = job_config['class'] || job_config[:class]
         begin
-          klass = Resque::Scheduler::Util.constantize(klass_name)
+          klass = ResqueAdmin::Scheduler::Util.constantize(klass_name)
         rescue NameError
           klass = klass_name
         end
@@ -236,45 +236,45 @@ module Resque
         params = args.is_a?(Hash) ? [args] : Array(args)
         queue = job_config['queue'] ||
                 job_config[:queue] ||
-                Resque.queue_from_class(klass)
+                ResqueAdmin.queue_from_class(klass)
         # Support custom job classes like those that inherit from
-        # Resque::JobWithStatus (resque-status)
+        # ResqueAdmin::JobWithStatus (resque-status)
         job_klass = job_config['custom_job_class']
-        if job_klass && job_klass != 'Resque::Job'
+        if job_klass && job_klass != 'ResqueAdmin::Job'
           # The custom job class API must offer a static "scheduled" method. If
           # the custom job class can not be constantized (via a requeue call
           # from the web perhaps), fall back to enqueing normally via
-          # Resque::Job.create.
+          # ResqueAdmin::Job.create.
           begin
-            Resque::Scheduler::Util.constantize(job_klass).scheduled(
+            ResqueAdmin::Scheduler::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)
+            ResqueAdmin::Job.create(queue, job_klass, *params)
           end
         else
           # Hack to avoid havoc for people shoving stuff into queues
           # for non-existent classes (for example: running scheduler in
           # one app that schedules for another.
           if Class === klass
-            Resque::Scheduler::Plugin.run_before_delayed_enqueue_hooks(
+            ResqueAdmin::Scheduler::Plugin.run_before_delayed_enqueue_hooks(
               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.
+            # This allows you to do things like ResqueAdmin.enqueue_at(timestamp,
+            # CustomJobClass). Otherwise, pass off to ResqueAdmin.
             if klass.respond_to?(:scheduled)
               klass.scheduled(queue, klass_name, *params)
             else
-              Resque.enqueue_to(queue, klass, *params)
+              ResqueAdmin.enqueue_to(queue, klass, *params)
             end
           else
             # This will not run the before_hooks in rescue, but will at least
             # queue the job.
-            Resque::Job.create(queue, klass, *params)
+            ResqueAdmin::Job.create(queue, klass, *params)
           end
         end
       end
@@ -299,15 +299,15 @@ module Resque
       end
 
       def update_schedule
-        if Resque.redis.scard(:schedules_changed) > 0
+        if ResqueAdmin.redis.scard(:schedules_changed) > 0
           procline 'Updating schedule'
           loop do
-            schedule_name = Resque.redis.spop(:schedules_changed)
+            schedule_name = ResqueAdmin.redis.spop(:schedules_changed)
             break unless schedule_name
-            Resque.reload_schedule!
-            if Resque.schedule.keys.include?(schedule_name)
+            ResqueAdmin.reload_schedule!
+            if ResqueAdmin.schedule.keys.include?(schedule_name)
               unschedule_job(schedule_name)
-              load_schedule_job(schedule_name, Resque.schedule[schedule_name])
+              load_schedule_job(schedule_name, ResqueAdmin.schedule[schedule_name])
             else
               unschedule_job(schedule_name)
             end
@@ -405,11 +405,11 @@ module Resque
       end
 
       def failure_handler
-        @failure_handler ||= Resque::Scheduler::FailureHandler
+        @failure_handler ||= ResqueAdmin::Scheduler::FailureHandler
       end
 
       def logger
-        @logger ||= Resque::Scheduler::LoggerBuilder.new(
+        @logger ||= ResqueAdmin::Scheduler::LoggerBuilder.new(
           quiet: quiet,
           verbose: verbose,
           log_dev: logfile,
@@ -422,7 +422,7 @@ module Resque
       def enqueue_recurring(name, config)
         if master?
           log! "queueing #{config['class']} (#{name})"
-          Resque.last_enqueued_at(name, Time.now.to_s)
+          ResqueAdmin.last_enqueued_at(name, Time.now.to_s)
           enqueue(config)
         end
       end
@@ -440,7 +440,7 @@ module Resque
       end
 
       def internal_name
-        "resque-scheduler-#{Resque::Scheduler::VERSION}"
+        "resque-scheduler-#{ResqueAdmin::Scheduler::VERSION}"
       end
     end
   end

data/lib/{resque → resque-admin}/scheduler/cli.rb

@@ -2,7 +2,7 @@
 
 require 'optparse'
 
-module Resque
+module ResqueAdmin
   module Scheduler
     CLI_OPTIONS_ENV_MAPPING = {
       app_name: 'APP_NAME',
@@ -114,7 +114,7 @@ module Resque
       end
 
       def run_forever
-        Resque::Scheduler.run
+        ResqueAdmin::Scheduler.run
       end
 
       private
@@ -122,13 +122,13 @@ module Resque
       attr_reader :argv, :env
 
       def runtime_env
-        @runtime_env ||= Resque::Scheduler::Env.new(options)
+        @runtime_env ||= ResqueAdmin::Scheduler::Env.new(options)
       end
 
       def option_parser
         OptionParser.new do |opts|
           opts.banner = BANNER
-          opts.version = Resque::Scheduler::VERSION
+          opts.version = ResqueAdmin::Scheduler::VERSION
           OPTIONS.each do |opt|
             opts.on(*opt[:args], &opt[:callback].call(options))
           end

data/lib/{resque → resque-admin}/scheduler/configuration.rb

@@ -1,6 +1,6 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module Configuration
       # Allows for block-style configuration

data/lib/{resque → resque-admin}/scheduler/delaying_extensions.rb

@@ -3,7 +3,7 @@ require 'resque'
 require_relative 'plugin'
 require_relative '../scheduler'
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module DelayingExtensions
       # This method is nearly identical to +enqueue+ only it also
@@ -19,21 +19,21 @@ module Resque
 
       # Identical to +enqueue_at+, except you can also specify
       # a queue in which the job will be placed after the
-      # timestamp has passed. It respects Resque.inline option, by
+      # timestamp has passed. It respects ResqueAdmin.inline option, by
       # creating the job right away instead of adding to the queue.
       def enqueue_at_with_queue(queue, timestamp, klass, *args)
         return false unless plugin.run_before_schedule_hooks(klass, *args)
 
-        if Resque.inline? || timestamp.to_i < Time.now.to_i
+        if ResqueAdmin.inline? || timestamp.to_i < Time.now.to_i
           # Just create the job and let resque perform it right away with
           # inline.  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, :opt1 => val1).
-          # Otherwise, pass off to Resque.
+          # ResqueAdmin.enqueue_at(timestamp, CustomJobClass, :opt1 => val1).
+          # Otherwise, pass off to ResqueAdmin.
           if klass.respond_to?(:scheduled)
             klass.scheduled(queue, klass.to_s, *args)
           else
-            Resque::Job.create(queue, klass, *args)
+            ResqueAdmin::Job.create(queue, klass, *args)
           end
         else
           delayed_push(timestamp, job_to_hash_with_queue(queue, klass, args))
@@ -147,7 +147,7 @@ module Resque
       def enqueue_delayed(klass, *args)
         hash = job_to_hash(klass, args)
         remove_delayed(klass, *args).times do
-          Resque::Scheduler.enqueue_from_config(hash)
+          ResqueAdmin::Scheduler.enqueue_from_config(hash)
         end
       end
 
@@ -210,7 +210,7 @@ module Resque
       # O(N) where N is the number of jobs scheduled to fire at the given
       # timestamp
       def remove_delayed_job_from_timestamp(timestamp, klass, *args)
-        return 0 if Resque.inline?
+        return 0 if ResqueAdmin.inline?
 
         key = "delayed:#{timestamp.to_i}"
         encoded_job = encode(job_to_hash(klass, args))
@@ -232,8 +232,8 @@ module Resque
 
       # Discover if a job has been delayed.
       # Examples
-      #   Resque.delayed?(MyJob)
-      #   Resque.delayed?(MyJob, id: 1)
+      #   ResqueAdmin.delayed?(MyJob)
+      #   ResqueAdmin.delayed?(MyJob, id: 1)
       # Returns true if the job has been delayed
       def delayed?(klass, *args)
         !scheduled_at(klass, *args).empty?
@@ -266,7 +266,7 @@ module Resque
       end
 
       def remove_delayed_job(encoded_job)
-        return 0 if Resque.inline?
+        return 0 if ResqueAdmin.inline?
 
         timestamps = redis.smembers("timestamps:#{encoded_job}")
 
@@ -317,7 +317,7 @@ module Resque
       end
 
       def plugin
-        Resque::Scheduler::Plugin
+        ResqueAdmin::Scheduler::Plugin
       end
     end
   end

data/lib/{resque → resque-admin}/scheduler/env.rb

@@ -2,7 +2,7 @@
 
 require 'English' # $PROCESS_ID
 
-module Resque
+module ResqueAdmin
   module Scheduler
     class Env
       def initialize(options)
@@ -12,7 +12,7 @@ module Resque
 
       def setup
         require 'resque'
-        require 'resque/scheduler'
+        require 'resque-admin/scheduler'
 
         setup_backgrounding
         setup_pid_file
@@ -32,7 +32,7 @@ module Resque
 
         # Need to set this here for conditional Process.daemon redirect of
         # stderr/stdout to /dev/null
-        Resque::Scheduler.quiet = if options.key?(:quiet)
+        ResqueAdmin::Scheduler.quiet = if options.key?(:quiet)
                                     !!options[:quiet]
                                   else
                                     true
@@ -42,8 +42,8 @@ module Resque
           abort 'background option is set, which requires ruby >= 1.9'
         end
 
-        Process.daemon(true, !Resque::Scheduler.quiet)
-        Resque.redis.client.reconnect
+        Process.daemon(true, !ResqueAdmin::Scheduler.quiet)
+        ResqueAdmin.redis.client.reconnect
       end
 
       def setup_pid_file
@@ -59,7 +59,7 @@ module Resque
       end
 
       def setup_scheduler_configuration
-        Resque::Scheduler.configure do |c|
+        ResqueAdmin::Scheduler.configure do |c|
           c.app_name = options[:app_name] if options.key?(:app_name)
 
           c.dynamic = !!options[:dynamic] if options.key?(:dynamic)

data/lib/{resque → resque-admin}/scheduler/extension.rb

@@ -3,7 +3,7 @@
 require_relative 'scheduling_extensions'
 require_relative 'delaying_extensions'
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module Extension
       include SchedulingExtensions

data/lib/{resque → resque-admin}/scheduler/failure_handler.rb

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

data/lib/{resque → resque-admin}/scheduler/lock.rb

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

data/lib/{resque → resque-admin}/scheduler/lock/base.rb

@@ -1,6 +1,6 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module Lock
       class Base
@@ -30,7 +30,7 @@ module Resque
 
         # Releases the lock.
         def release!
-          Resque.redis.del(key) == 1
+          ResqueAdmin.redis.del(key) == 1
         end
 
         # Releases the lock iff we own it
@@ -42,7 +42,7 @@ module Resque
 
         # Extends the lock by `timeout` seconds.
         def extend_lock!
-          Resque.redis.expire(key, timeout)
+          ResqueAdmin.redis.expire(key, timeout)
         end
 
         def hostname

data/lib/{resque → resque-admin}/scheduler/lock/basic.rb

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

data/lib/{resque → resque-admin}/scheduler/lock/resilient.rb

@@ -1,7 +1,7 @@
 # vim:fileencoding=utf-8
 require_relative 'base'
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module Lock
       class Resilient < Base
@@ -26,7 +26,7 @@ module Resque
 
         def evalsha(script, keys, argv, refresh: false)
           sha_method_name = "#{script}_sha"
-          Resque.redis.evalsha(
+          ResqueAdmin.redis.evalsha(
             send(sha_method_name, refresh),
             keys: keys,
             argv: argv
@@ -43,7 +43,7 @@ module Resque
           @locked_sha = nil if refresh
 
           @locked_sha ||=
-            Resque.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
+            ResqueAdmin.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
               if redis.call('GET', KEYS[1]) == ARGV[1]
               then
                 redis.call('EXPIRE', KEYS[1], #{timeout})
@@ -62,7 +62,7 @@ module Resque
           @acquire_sha = nil if refresh
 
           @acquire_sha ||=
-            Resque.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
+            ResqueAdmin.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
               if redis.call('SETNX', KEYS[1], ARGV[1]) == 1
               then
                 redis.call('EXPIRE', KEYS[1], #{timeout})

data/lib/{resque → resque-admin}/scheduler/locking.rb

@@ -51,7 +51,7 @@
 
 require_relative 'lock'
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module Locking
       def master_lock
@@ -84,20 +84,20 @@ module Resque
 
       def build_master_lock
         if supports_lua?
-          Resque::Scheduler::Lock::Resilient.new(master_lock_key)
+          ResqueAdmin::Scheduler::Lock::Resilient.new(master_lock_key)
         else
-          Resque::Scheduler::Lock::Basic.new(master_lock_key)
+          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 != ''
-        "#{Resque.redis.namespace}:#{lock_prefix}resque_scheduler_master_lock"
+        "#{ResqueAdmin.redis.namespace}:#{lock_prefix}resque_scheduler_master_lock"
       end
 
       def redis_master_version
-        Resque.redis.info['redis_version'].to_f
+        ResqueAdmin.redis.info['redis_version'].to_f
       end
     end
   end

data/lib/{resque → resque-admin}/scheduler/logger_builder.rb

@@ -2,12 +2,12 @@
 
 require 'mono_logger'
 
-module Resque
+module ResqueAdmin
   module Scheduler
     # Just builds a logger, with specified verbosity and destination.
     # The simplest example:
     #
-    #   Resque::Scheduler::LoggerBuilder.new.build
+    #   ResqueAdmin::Scheduler::LoggerBuilder.new.build
     class LoggerBuilder
       # Initializes new instance of the builder
       #

data/lib/{resque → resque-admin}/scheduler/plugin.rb

@@ -1,6 +1,6 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module Plugin
       def self.hooks(job, pattern)

data/lib/{resque → resque-admin}/scheduler/scheduling_extensions.rb

@@ -1,6 +1,6 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module SchedulingExtensions
       # Accepts a new schedule configuration of the form:
@@ -76,7 +76,7 @@ module Resque
       # Note: values for class and custom_job_class need to be strings,
       # not constants.
       #
-      #    Resque.set_schedule('some_job', {:class => 'SomeJob',
+      #    ResqueAdmin.set_schedule('some_job', {:class => 'SomeJob',
       #                                     :every => '15mins',
       #                                     :queue => 'high',
       #                                     :args => '/tmp/poop'})

data/lib/{resque → resque-admin}/scheduler/server.rb

@@ -1,16 +1,16 @@
 # vim:fileencoding=utf-8
 require 'resque-scheduler'
-require 'resque/server'
+require 'resque-admin/server'
 require 'tilt/erb'
 require 'json'
 
-# Extend Resque::Server to add tabs
-module Resque
+# Extend ResqueAdmin::Server to add tabs
+module ResqueAdmin
   module Scheduler
     module Server
       TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S %z'.freeze
 
-      unless defined?(::Resque::Scheduler::Server::VIEW_PATH)
+      unless defined?(::ResqueAdmin::Scheduler::Server::VIEW_PATH)
         VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
       end
 
@@ -37,25 +37,25 @@ module Resque
 
       module ServerMethods
         def schedule
-          Resque.reload_schedule! if Resque::Scheduler.dynamic
+          ResqueAdmin.reload_schedule! if ResqueAdmin::Scheduler.dynamic
           erb scheduler_template('scheduler')
         end
 
         def schedule_requeue
           @job_name = params['job_name'] || params[:job_name]
-          config = Resque.schedule[@job_name]
+          config = ResqueAdmin.schedule[@job_name]
           @parameters = config['parameters'] || config[:parameters]
           if @parameters
             erb scheduler_template('requeue-params')
           else
-            Resque::Scheduler.enqueue_from_config(config)
+            ResqueAdmin::Scheduler.enqueue_from_config(config)
             redirect u('/overview')
           end
         end
 
         def schedule_requeue_with_params
           job_name = params['job_name'] || params[:job_name]
-          config = Resque.schedule[job_name]
+          config = ResqueAdmin.schedule[job_name]
           # Build args hash from post data (removing the job name)
           submitted_args = params.reject do |key, _value|
             key == 'job_name' || key == :job_name
@@ -68,14 +68,14 @@ module Resque
 
           # Insert the args hash into config and queue the resque job
           config = config.merge('args' => config_args)
-          Resque::Scheduler.enqueue_from_config(config)
+          ResqueAdmin::Scheduler.enqueue_from_config(config)
           redirect u('/overview')
         end
 
         def delete_schedule
-          if Resque::Scheduler.dynamic
+          if ResqueAdmin::Scheduler.dynamic
             job_name = params['job_name'] || params[:job_name]
-            Resque.remove_schedule(job_name)
+            ResqueAdmin.remove_schedule(job_name)
           end
           redirect u('/schedule')
         end
@@ -86,9 +86,9 @@ module Resque
 
         def delayed_jobs_klass
           begin
-            klass = Resque::Scheduler::Util.constantize(params[:klass])
+            klass = ResqueAdmin::Scheduler::Util.constantize(params[:klass])
             @args = JSON.load(URI.decode(params[:args]))
-            @timestamps = Resque.scheduled_at(klass, *@args)
+            @timestamps = ResqueAdmin.scheduled_at(klass, *@args)
           rescue
             @timestamps = []
           end
@@ -108,11 +108,11 @@ module Resque
         def delayed_queue_now
           timestamp = params['timestamp'].to_i
           formatted_time = Time.at(timestamp).strftime(
-            ::Resque::Scheduler::Server::TIMESTAMP_FORMAT
+            ::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT
           )
 
           if timestamp > 0
-            unless Resque::Scheduler.enqueue_next_item(timestamp)
+            unless ResqueAdmin::Scheduler.enqueue_next_item(timestamp)
               @error_message = "Unable to remove item at #{formatted_time}"
             end
           else
@@ -123,22 +123,22 @@ module Resque
         end
 
         def delayed_cancel_now
-          klass = Resque::Scheduler::Util.constantize(params['klass'])
+          klass = ResqueAdmin::Scheduler::Util.constantize(params['klass'])
           timestamp = params['timestamp']
-          args = Resque.decode params['args']
-          Resque.remove_delayed_job_from_timestamp(timestamp, klass, *args)
+          args = ResqueAdmin.decode params['args']
+          ResqueAdmin.remove_delayed_job_from_timestamp(timestamp, klass, *args)
           redirect u('/delayed')
         end
 
         def delayed_clear
-          Resque.reset_delayed_queue
+          ResqueAdmin.reset_delayed_queue
           redirect u('delayed')
         end
       end
 
       module HelperMethods
         def format_time(t)
-          t.strftime(::Resque::Scheduler::Server::TIMESTAMP_FORMAT)
+          t.strftime(::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT)
         end
 
         def show_job_arguments(args)
@@ -146,8 +146,8 @@ module Resque
         end
 
         def queue_from_class_name(class_name)
-          Resque.queue_from_class(
-            Resque::Scheduler::Util.constantize(class_name)
+          ResqueAdmin.queue_from_class(
+            ResqueAdmin::Scheduler::Util.constantize(class_name)
           )
         end
 
@@ -161,8 +161,8 @@ module Resque
               j.merge!('where_at' => 'delayed')
           end
 
-          Resque.queues.each do |queue|
-            queued = Resque.peek(queue, 0, Resque.size(queue))
+          ResqueAdmin.queues.each do |queue|
+            queued = ResqueAdmin.peek(queue, 0, ResqueAdmin.size(queue))
             queued = [queued] unless queued.is_a?(Array)
             results += queued.select do |j|
               j['class'].downcase.include?(worker) &&
@@ -212,11 +212,11 @@ module Resque
 
         def scheduled_in_this_env?(name)
           return true if rails_env(name).nil?
-          rails_env(name).split(/[\s,]+/).include?(Resque::Scheduler.env)
+          rails_env(name).split(/[\s,]+/).include?(ResqueAdmin::Scheduler.env)
         end
 
         def rails_env(name)
-          Resque.schedule[name]['rails_env'] || Resque.schedule[name]['env']
+          ResqueAdmin.schedule[name]['rails_env'] || ResqueAdmin.schedule[name]['env']
         end
 
         def scheduler_view(filename, options = {}, locals = {})
@@ -228,7 +228,7 @@ module Resque
 
         def working_jobs_for_worker(worker)
           [].tap do |results|
-            working = [*Resque.working]
+            working = [*ResqueAdmin.working]
             work = working.select do |w|
               w.job && w.job['payload'] &&
                 w.job['payload']['class'].downcase.include?(worker)
@@ -245,10 +245,10 @@ module Resque
 
         def delayed_jobs_for_worker(_worker)
           [].tap do |dels|
-            schedule_size = Resque.delayed_queue_schedule_size
-            Resque.delayed_queue_peek(0, schedule_size).each do |d|
-              Resque.delayed_timestamp_peek(
-                d, 0, Resque.delayed_timestamp_size(d)
+            schedule_size = ResqueAdmin.delayed_queue_schedule_size
+            ResqueAdmin.delayed_queue_peek(0, schedule_size).each do |d|
+              ResqueAdmin.delayed_timestamp_peek(
+                d, 0, ResqueAdmin.delayed_timestamp_size(d)
               ).each do |j|
                 dels << j.merge!('timestamp' => d)
               end
@@ -260,9 +260,9 @@ module Resque
   end
 end
 
-Resque::Server.tabs << 'Schedule'
-Resque::Server.tabs << 'Delayed'
+ResqueAdmin::Server.tabs << 'Schedule'
+ResqueAdmin::Server.tabs << 'Delayed'
 
-Resque::Server.class_eval do
-  include Resque::Scheduler::Server
+ResqueAdmin::Server.class_eval do
+  include ResqueAdmin::Scheduler::Server
 end

data/lib/{resque → resque-admin}/scheduler/server/views/scheduler.erb

@@ -4,8 +4,8 @@
   The list below contains all scheduled jobs.  Click "Queue now" to queue
   a job immediately.
   <br/> Server local time: <%= Time.now %>
-  <br/> Server Environment: <%= Resque::Scheduler.env %>
-  <br/> Current master: <%= Resque.redis.get(Resque::Scheduler.master_lock.key) %>
+  <br/> Server Environment: <%= ResqueAdmin::Scheduler.env %>
+  <br/> Current master: <%= ResqueAdmin.redis.get(ResqueAdmin::Scheduler.master_lock.key) %>
 </p>
 <p class='intro'>
 	The highlighted jobs are skipped for current environment.
@@ -14,7 +14,7 @@
 <table>
   <tr>
     <th>Index</th>
-    <% if Resque::Scheduler.dynamic %>
+    <% if ResqueAdmin::Scheduler.dynamic %>
       <th></th>
   <% end %>
     <th></th>
@@ -26,11 +26,11 @@
     <th>Arguments</th>
     <th>Last Enqueued</th>
   </tr>
-  <% Resque.schedule.keys.sort.each_with_index do |name, index| %>
-    <% config = Resque.schedule[name] %>
+  <% ResqueAdmin.schedule.keys.sort.each_with_index do |name, index| %>
+    <% config = ResqueAdmin.schedule[name] %>
     <tr style="<%= scheduled_in_this_env?(name) ? '' : 'color: #9F6000;background: #FEEFB3;' %>">
 	    <td style="padding-left: 15px;"><%= index+ 1 %>.</td>
-      <% if Resque::Scheduler.dynamic %>
+      <% if ResqueAdmin::Scheduler.dynamic %>
         <td style="padding-top: 12px; padding-bottom: 2px; width: 10px">
           <form action="<%= u "/schedule" %>" method="post" style="margin-left: 0">
             <input type="hidden" name="job_name" value="<%= h name %>">
@@ -51,7 +51,7 @@
       <td><%= h schedule_class(config) %></td>
       <td><%= h config['queue'] || queue_from_class_name(config['class']) %></td>
       <td><%= h show_job_arguments(config['args']) %></td>
-      <td><%= h Resque.get_last_enqueued_at(name) || 'Never' %></td>
+      <td><%= h ResqueAdmin.get_last_enqueued_at(name) || 'Never' %></td>
     </tr>
   <% end %>
 </table>

data/lib/{resque → resque-admin}/scheduler/server/views/search.erb

@@ -23,7 +23,7 @@
           <form action="<%= u "/delayed/cancel_now" %>" method="post">
             <input type="hidden" name="timestamp" value="<%= job['timestamp'].to_i %>">
             <input type="hidden" name="klass" value="<%= job['class'] %>">
-            <input type="hidden" name="args" value="<%= h(Resque.encode job['args']) %>">
+            <input type="hidden" name="args" value="<%= h(ResqueAdmin.encode job['args']) %>">
             <input type="submit" value="Cancel Job">
           </form>
         </td>

data/lib/{resque → resque-admin}/scheduler/signal_handling.rb

@@ -1,6 +1,6 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
     module SignalHandling
       attr_writer :signal_queue

data/lib/{resque → resque-admin}/scheduler/tasks.rb

@@ -1,18 +1,18 @@
 # vim:fileencoding=utf-8
 
-require 'resque/tasks'
+require 'resque-admin/tasks'
 require 'resque-scheduler'
 
 namespace :resque do
   task :setup
 
   def scheduler_cli
-    @scheduler_cli ||= Resque::Scheduler::Cli.new(
+    @scheduler_cli ||= ResqueAdmin::Scheduler::Cli.new(
       %W(#{ENV['RESQUE_SCHEDULER_OPTIONS']})
     )
   end
 
-  desc 'Start Resque Scheduler'
+  desc 'Start ResqueAdmin Scheduler'
   task scheduler: :scheduler_setup do
     scheduler_cli.setup_env
     scheduler_cli.run_forever

data/lib/{resque → resque-admin}/scheduler/util.rb

@@ -1,10 +1,10 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
     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
+      # methods, we just added these usefull helpers back to use in ResqueAdmin
       # Scheduler.  refer to:
       # https://github.com/resque/resque-scheduler/pull/273
 

data/lib/{resque → resque-admin}/scheduler/version.rb

@@ -1,7 +1,7 @@
 # vim:fileencoding=utf-8
 
-module Resque
+module ResqueAdmin
   module Scheduler
-    VERSION = '1.0.2'.freeze
+    VERSION = '1.0.3'.freeze
   end
 end

data/lib/resque-scheduler.rb

@@ -1,4 +1,4 @@
 # vim:fileencoding=utf-8
-require_relative 'resque/scheduler'
+require_relative 'resque-admin/scheduler'
 
-Resque.extend Resque::Scheduler::Extension
+ResqueAdmin.extend ResqueAdmin::Scheduler::Extension

data/tasks/resque_scheduler.rake

@@ -1,2 +1,2 @@
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'resque/scheduler/tasks'
+require 'resque-admin/scheduler/tasks'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque_admin-scheduler
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Ben VandenBos
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-22 00:00:00.000000000 Z
+date: 2017-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -196,7 +196,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.40.0
 description: |2
-      Light weight job scheduling on top of ResqueAdmin.
+      Light weight job scheduling on top of ResqueAdminAdmin.
       Adds methods enqueue_at/enqueue_in to schedule jobs in the future.
       Also supports queueing jobs on a fixed, cron-like schedule.
 email:
@@ -211,34 +211,34 @@ extra_rdoc_files: []
 files:
 - bin/migrate_to_timestamps_set.rb
 - exe/resque-scheduler
+- lib/resque-admin/scheduler.rb
+- lib/resque-admin/scheduler/cli.rb
+- lib/resque-admin/scheduler/configuration.rb
+- lib/resque-admin/scheduler/delaying_extensions.rb
+- lib/resque-admin/scheduler/env.rb
+- lib/resque-admin/scheduler/extension.rb
+- lib/resque-admin/scheduler/failure_handler.rb
+- lib/resque-admin/scheduler/lock.rb
+- lib/resque-admin/scheduler/lock/base.rb
+- lib/resque-admin/scheduler/lock/basic.rb
+- lib/resque-admin/scheduler/lock/resilient.rb
+- lib/resque-admin/scheduler/locking.rb
+- lib/resque-admin/scheduler/logger_builder.rb
+- lib/resque-admin/scheduler/plugin.rb
+- lib/resque-admin/scheduler/scheduling_extensions.rb
+- lib/resque-admin/scheduler/server.rb
+- lib/resque-admin/scheduler/server/views/delayed.erb
+- lib/resque-admin/scheduler/server/views/delayed_schedules.erb
+- lib/resque-admin/scheduler/server/views/delayed_timestamp.erb
+- lib/resque-admin/scheduler/server/views/requeue-params.erb
+- lib/resque-admin/scheduler/server/views/scheduler.erb
+- lib/resque-admin/scheduler/server/views/search.erb
+- lib/resque-admin/scheduler/server/views/search_form.erb
+- lib/resque-admin/scheduler/signal_handling.rb
+- lib/resque-admin/scheduler/tasks.rb
+- lib/resque-admin/scheduler/util.rb
+- lib/resque-admin/scheduler/version.rb
 - lib/resque-scheduler.rb
-- lib/resque/scheduler.rb
-- lib/resque/scheduler/cli.rb
-- lib/resque/scheduler/configuration.rb
-- lib/resque/scheduler/delaying_extensions.rb
-- lib/resque/scheduler/env.rb
-- lib/resque/scheduler/extension.rb
-- lib/resque/scheduler/failure_handler.rb
-- lib/resque/scheduler/lock.rb
-- lib/resque/scheduler/lock/base.rb
-- lib/resque/scheduler/lock/basic.rb
-- lib/resque/scheduler/lock/resilient.rb
-- lib/resque/scheduler/locking.rb
-- lib/resque/scheduler/logger_builder.rb
-- lib/resque/scheduler/plugin.rb
-- lib/resque/scheduler/scheduling_extensions.rb
-- lib/resque/scheduler/server.rb
-- lib/resque/scheduler/server/views/delayed.erb
-- lib/resque/scheduler/server/views/delayed_schedules.erb
-- lib/resque/scheduler/server/views/delayed_timestamp.erb
-- lib/resque/scheduler/server/views/requeue-params.erb
-- lib/resque/scheduler/server/views/scheduler.erb
-- lib/resque/scheduler/server/views/search.erb
-- lib/resque/scheduler/server/views/search_form.erb
-- lib/resque/scheduler/signal_handling.rb
-- lib/resque/scheduler/tasks.rb
-- lib/resque/scheduler/util.rb
-- lib/resque/scheduler/version.rb
 - tasks/resque_scheduler.rake
 homepage: http://github.com/resque_admin/resque_admin-scheduler
 licenses:
@@ -263,5 +263,5 @@ rubyforge_project:
 rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
-summary: Light weight job scheduling on top of ResqueAdmin
+summary: Light weight job scheduling on top of ResqueAdminAdmin
 test_files: []