resque-admin-scheduler 1.0.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6160d26c46865fb0fc43c0bff6d1c7aec56e8181
-  data.tar.gz: fb5889c360f0fddd2eeb5730b2fcdad4f4f84392
+  metadata.gz: 480fe9565b4e589d1af66f650d235c2cb1d17db5
+  data.tar.gz: 4ec0e5445bcb1b6cbb404ed1fe0d4e17c132cd4c
 SHA512:
-  metadata.gz: 689647490f5553918f78c8341f27f232fb5424b8b0f561123671ffe461517879609d651597be86f992fc8dd1c495b543b7a70bba365b56bdb6c17c2202a6c5e8
-  data.tar.gz: bd77fb6cac438fa114c355599b595a01ffa55f3c16ac936c914950a9fb495db6315b32c8f4c2e007ad5ce7a1e51443f9b37bb3d1426de0782858324d57aa5c77
+  metadata.gz: 46cc8ebbab4bae754421bd24b5a5e02e5b9762b3851ba38c9f2f543203907739c28fc0730d28e558f326c05a150f3c584cfd421116a6975274aabf0d5b1040cd
+  data.tar.gz: bd36ba04d100a60dea2599222b5a937aabe8dcc4c59351193ac8f0bcff3e0b74406d03f8b4eee35f5c67e18e4fdbbb4709480ca7c86c544b008b0eb48c528cf6

data/bin/migrate_to_timestamps_set.rb

@@ -0,0 +1,16 @@
+# vim:fileencoding=utf-8
+
+require 'redis'
+require 'resque_admin'
+
+if ARGV.size != 1
+  puts 'migrate_to_timestamps_set.rb <redis-host:redis-port>'
+  exit
+end
+
+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) }
+end

data/exe/resque-scheduler

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 # vim:fileencoding=utf-8
 
-require 'resque-scheduler'
-Resque::Scheduler::Cli.run!
+require 'resque_admin-scheduler'
+ResqueAdmin::Scheduler::Cli.run!

data/lib/resque/scheduler/cli.rb

@@ -2,7 +2,7 @@
 
 require 'optparse'
 
-module Resque
+module ResqueAdmin
   module Scheduler
     CLI_OPTIONS_ENV_MAPPING = {
       app_name: 'APP_NAME',
@@ -20,9 +20,9 @@ module Resque
 
     class Cli
       BANNER = <<-EOF.gsub(/ {6}/, '')
-      Usage: resque-scheduler [options]
+      Usage: resque_admin-scheduler [options]
 
-      Runs a resque scheduler process directly (rather than via rake).
+      Runs a resque_admin scheduler process directly (rather than via rake).
 
       EOF
       OPTIONS = [
@@ -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/scheduler/delaying_extensions.rb

@@ -1,9 +1,9 @@
 # vim:fileencoding=utf-8
-require 'resque'
+require 'resque_admin'
 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
-          # Just create the job and let resque perform it right away with
+        if ResqueAdmin.inline? || timestamp.to_i < Time.now.to_i
+          # Just create the job and let resque_admin 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/scheduler/env.rb

@@ -2,7 +2,7 @@
 
 require 'English' # $PROCESS_ID
 
-module Resque
+module ResqueAdmin
   module Scheduler
     class Env
       def initialize(options)
@@ -11,8 +11,8 @@ module Resque
       end
 
       def setup
-        require 'resque'
-        require 'resque/scheduler'
+        require 'resque_admin'
+        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/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/scheduler/locking.rb

@@ -2,7 +2,7 @@
 
 # ### Locking the scheduler process
 #
-# There are two places in resque-scheduler that need to be synchonized in order
+# There are two places in resque_admin-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.
 #
@@ -23,7 +23,7 @@
 # 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
+# Locking Scheme: Each resque_admin-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
@@ -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/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
       #
@@ -51,7 +51,7 @@ module Resque
 
       def text_formatter
         proc do |severity, datetime, _progname, msg|
-          "resque-scheduler: [#{severity}] #{datetime.iso8601}: #{msg}\n"
+          "resque_admin-scheduler: [#{severity}] #{datetime.iso8601}: #{msg}\n"
         end
       end
 
@@ -59,7 +59,7 @@ module Resque
         proc do |severity, datetime, progname, msg|
           require 'json'
           JSON.dump(
-            name: 'resque-scheduler',
+            name: 'resque_admin-scheduler',
             progname: progname,
             level: severity,
             timestamp: datetime.iso8601,

data/lib/resque/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:
@@ -19,7 +19,7 @@ module Resque
       # Hash keys can be anything and are used to describe and reference
       # the scheduled job. If the "class" argument is missing, the key
       # is used implicitly as "class" argument - in the "MakeTea" example,
-      # "MakeTea" is used both as job name and resque worker class.
+      # "MakeTea" is used both as job name and resque_admin worker class.
       #
       # Any jobs that were in the old schedule, but are not
       # present in the new schedule, will be removed.
@@ -30,7 +30,7 @@ module Resque
       # usage for valid syntax. If :cron is present it will take precedence
       # over :every.
       #
-      # :class must be a resque worker class. If it is missing, the job name
+      # :class must be a resque_admin worker class. If it is missing, the job name
       # (hash key) will be used as :class.
       #
       # :args can be any yaml which will be converted to a ruby literal and
@@ -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/scheduler/server/views/delayed.erb

@@ -1,5 +1,5 @@
 <h1>Delayed Jobs</h1>
-<%- size = resque.delayed_queue_schedule_size %>
+<%- size = resque_admin.delayed_queue_schedule_size %>
 
 <%= scheduler_view :search_form, layout: false %>
 
@@ -25,7 +25,7 @@
     <th>Args</th>
     <th>All schedules</th>
   </tr>
-  <% resque.delayed_queue_peek(start, 20).each do |timestamp| %>
+  <% resque_admin.delayed_queue_peek(start, 20).each do |timestamp| %>
     <tr>
       <td>
         <form action="<%= u "/delayed/queue_now" %>" method="post">
@@ -34,8 +34,8 @@
         </form>
       </td>
       <td><a href="<%= u "delayed/#{timestamp}" %>"><%= format_time(Time.at(timestamp)) %></a></td>
-      <td><%= delayed_timestamp_size = resque.delayed_timestamp_size(timestamp) %></td>
-      <% job = resque.delayed_timestamp_peek(timestamp, 0, 1).first %>
+      <td><%= delayed_timestamp_size = resque_admin.delayed_timestamp_size(timestamp) %></td>
+      <% job = resque_admin.delayed_timestamp_peek(timestamp, 0, 1).first %>
       <td>
         <% if job && delayed_timestamp_size == 1 %>
           <%= h(job['class']) %>

data/lib/resque/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/scheduler/server.rb

@@ -1,16 +1,16 @@
 # vim:fileencoding=utf-8
-require 'resque-scheduler'
-require 'resque/server'
+require 'resque_admin-scheduler'
+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
@@ -66,16 +66,16 @@ module Resque
           config_args = config['args'] || config[:args] || {}
           config_args = config_args.merge(submitted_args)
 
-          # Insert the args hash into config and queue the resque job
+          # Insert the args hash into config and queue the resque_admin 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/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/scheduler/tasks.rb

@@ -1,18 +1,18 @@
 # vim:fileencoding=utf-8
 
-require 'resque/tasks'
-require 'resque-scheduler'
+require 'resque_admin/tasks'
+require 'resque_admin-scheduler'
 
-namespace :resque do
+namespace :resque_admin 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
@@ -20,6 +20,6 @@ namespace :resque do
 
   task :scheduler_setup do
     scheduler_cli.parse_options
-    Rake::Task['resque:setup'].invoke unless scheduler_cli.pre_setup
+    Rake::Task['resque_admin:setup'].invoke unless scheduler_cli.pre_setup
   end
 end

data/lib/resque/scheduler/util.rb

@@ -1,12 +1,12 @@
 # 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
+      # In order to upgrade to resque_admin(1.25) which has deprecated following
+      # methods, we just added these usefull helpers back to use in ResqueAdmin
       # Scheduler.  refer to:
-      # https://github.com/resque/resque-scheduler/pull/273
+      # https://github.com/resque_admin/resque_admin-scheduler/pull/273
 
       def self.constantize(camel_cased_word)
         camel_cased_word = camel_cased_word.to_s