resque-admin-scheduler 1.0.2 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (68) hide show
  1. checksums.yaml +4 -4
  2. data/bin/migrate_to_timestamps_set.rb +16 -0
  3. data/exe/resque-scheduler +2 -2
  4. data/lib/resque/scheduler/cli.rb +6 -6
  5. data/lib/resque/scheduler/delaying_extensions.rb +14 -14
  6. data/lib/resque/scheduler/env.rb +7 -7
  7. data/lib/resque/scheduler/lock.rb +1 -1
  8. data/lib/resque/scheduler/locking.rb +7 -7
  9. data/lib/resque/scheduler/logger_builder.rb +4 -4
  10. data/lib/resque/scheduler/scheduling_extensions.rb +4 -4
  11. data/lib/resque/scheduler/server/views/delayed.erb +4 -4
  12. data/lib/resque/scheduler/server/views/search.erb +1 -1
  13. data/lib/resque/scheduler/server.rb +37 -37
  14. data/lib/resque/scheduler/signal_handling.rb +1 -1
  15. data/lib/resque/scheduler/tasks.rb +6 -6
  16. data/lib/resque/scheduler/util.rb +4 -4
  17. data/lib/resque/scheduler_admin/cli.rb +147 -0
  18. data/lib/resque/scheduler_admin/delaying_extensions.rb +324 -0
  19. data/lib/resque/scheduler_admin/env.rb +89 -0
  20. data/lib/resque/scheduler_admin/lock.rb +4 -0
  21. data/lib/resque/scheduler_admin/locking.rb +104 -0
  22. data/lib/resque/scheduler_admin/logger_builder.rb +72 -0
  23. data/lib/resque/scheduler_admin/scheduling_extensions.rb +141 -0
  24. data/lib/resque/scheduler_admin/server/views/delayed.erb +63 -0
  25. data/lib/resque/scheduler_admin/server/views/search.erb +72 -0
  26. data/lib/resque/scheduler_admin/signal_handling.rb +40 -0
  27. data/lib/resque/scheduler_admin/tasks.rb +25 -0
  28. data/lib/resque/scheduler_admin/util.rb +39 -0
  29. data/lib/resque-admin-scheduler.rb +4 -0
  30. data/lib/resque_admin/scheduler/cli.rb +147 -0
  31. data/lib/{resque → resque_admin}/scheduler/configuration.rb +1 -1
  32. data/lib/resque_admin/scheduler/delaying_extensions.rb +324 -0
  33. data/lib/resque_admin/scheduler/env.rb +89 -0
  34. data/lib/{resque → resque_admin}/scheduler/extension.rb +1 -1
  35. data/lib/{resque → resque_admin}/scheduler/failure_handler.rb +2 -2
  36. data/lib/{resque → resque_admin}/scheduler/lock/base.rb +3 -3
  37. data/lib/{resque → resque_admin}/scheduler/lock/basic.rb +4 -4
  38. data/lib/{resque → resque_admin}/scheduler/lock/resilient.rb +4 -4
  39. data/lib/resque_admin/scheduler/lock.rb +4 -0
  40. data/lib/resque_admin/scheduler/locking.rb +104 -0
  41. data/lib/resque_admin/scheduler/logger_builder.rb +72 -0
  42. data/lib/{resque → resque_admin}/scheduler/plugin.rb +1 -1
  43. data/lib/resque_admin/scheduler/scheduling_extensions.rb +141 -0
  44. data/lib/resque_admin/scheduler/server/views/delayed.erb +63 -0
  45. data/lib/{resque → resque_admin}/scheduler/server/views/delayed_schedules.erb +0 -0
  46. data/lib/{resque → resque_admin}/scheduler/server/views/delayed_timestamp.erb +2 -2
  47. data/lib/{resque → resque_admin}/scheduler/server/views/requeue-params.erb +0 -0
  48. data/lib/{resque → resque_admin}/scheduler/server/views/scheduler.erb +7 -7
  49. data/lib/resque_admin/scheduler/server/views/search.erb +72 -0
  50. data/lib/{resque → resque_admin}/scheduler/server/views/search_form.erb +0 -0
  51. data/lib/resque_admin/scheduler/server.rb +268 -0
  52. data/lib/resque_admin/scheduler/signal_handling.rb +40 -0
  53. data/lib/resque_admin/scheduler/tasks.rb +25 -0
  54. data/lib/resque_admin/scheduler/util.rb +39 -0
  55. data/lib/{resque → resque_admin}/scheduler/version.rb +2 -2
  56. data/lib/{resque → resque_admin}/scheduler.rb +44 -44
  57. data/tasks/resque_admin_scheduler.rake +2 -0
  58. metadata +47 -85
  59. data/AUTHORS.md +0 -81
  60. data/CHANGELOG.md +0 -456
  61. data/CODE_OF_CONDUCT.md +0 -74
  62. data/CONTRIBUTING.md +0 -6
  63. data/Gemfile +0 -4
  64. data/LICENSE +0 -23
  65. data/README.md +0 -691
  66. data/Rakefile +0 -21
  67. data/lib/resque-scheduler.rb +0 -4
  68. data/resque-scheduler.gemspec +0 -60
@@ -0,0 +1,268 @@
1
+ # vim:fileencoding=utf-8
2
+ require 'resque_admin-scheduler'
3
+ require 'resque_admin/server'
4
+ require 'tilt/erb'
5
+ require 'json'
6
+
7
+ # Extend ResqueAdmin::Server to add tabs
8
+ module ResqueAdmin
9
+ module Scheduler
10
+ module Server
11
+ TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S %z'.freeze
12
+
13
+ unless defined?(::ResqueAdmin::Scheduler::Server::VIEW_PATH)
14
+ VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
15
+ end
16
+
17
+ def self.included(base)
18
+ base.class_eval do
19
+ helpers { include HelperMethods }
20
+ include ServerMethods
21
+
22
+ get('/schedule') { schedule }
23
+ post('/schedule/requeue') { schedule_requeue }
24
+ post('/schedule/requeue_with_params') do
25
+ schedule_requeue_with_params
26
+ end
27
+ delete('/schedule') { delete_schedule }
28
+ get('/delayed') { delayed }
29
+ get('/delayed/jobs/:klass') { delayed_jobs_klass }
30
+ post('/delayed/search') { delayed_search }
31
+ get('/delayed/:timestamp') { delayed_timestamp }
32
+ post('/delayed/queue_now') { delayed_queue_now }
33
+ post('/delayed/cancel_now') { delayed_cancel_now }
34
+ post('/delayed/clear') { delayed_clear }
35
+ end
36
+ end
37
+
38
+ module ServerMethods
39
+ def schedule
40
+ ResqueAdmin.reload_schedule! if ResqueAdmin::Scheduler.dynamic
41
+ erb scheduler_template('scheduler')
42
+ end
43
+
44
+ def schedule_requeue
45
+ @job_name = params['job_name'] || params[:job_name]
46
+ config = ResqueAdmin.schedule[@job_name]
47
+ @parameters = config['parameters'] || config[:parameters]
48
+ if @parameters
49
+ erb scheduler_template('requeue-params')
50
+ else
51
+ ResqueAdmin::Scheduler.enqueue_from_config(config)
52
+ redirect u('/overview')
53
+ end
54
+ end
55
+
56
+ def schedule_requeue_with_params
57
+ job_name = params['job_name'] || params[:job_name]
58
+ config = ResqueAdmin.schedule[job_name]
59
+ # Build args hash from post data (removing the job name)
60
+ submitted_args = params.reject do |key, _value|
61
+ key == 'job_name' || key == :job_name
62
+ end
63
+
64
+ # Merge constructed args hash with existing args hash for
65
+ # the job, if it exists
66
+ config_args = config['args'] || config[:args] || {}
67
+ config_args = config_args.merge(submitted_args)
68
+
69
+ # Insert the args hash into config and queue the resque_admin job
70
+ config = config.merge('args' => config_args)
71
+ ResqueAdmin::Scheduler.enqueue_from_config(config)
72
+ redirect u('/overview')
73
+ end
74
+
75
+ def delete_schedule
76
+ if ResqueAdmin::Scheduler.dynamic
77
+ job_name = params['job_name'] || params[:job_name]
78
+ ResqueAdmin.remove_schedule(job_name)
79
+ end
80
+ redirect u('/schedule')
81
+ end
82
+
83
+ def delayed
84
+ erb scheduler_template('delayed')
85
+ end
86
+
87
+ def delayed_jobs_klass
88
+ begin
89
+ klass = ResqueAdmin::Scheduler::Util.constantize(params[:klass])
90
+ @args = JSON.load(URI.decode(params[:args]))
91
+ @timestamps = ResqueAdmin.scheduled_at(klass, *@args)
92
+ rescue
93
+ @timestamps = []
94
+ end
95
+
96
+ erb scheduler_template('delayed_schedules')
97
+ end
98
+
99
+ def delayed_search
100
+ @jobs = find_job(params[:search])
101
+ erb scheduler_template('search')
102
+ end
103
+
104
+ def delayed_timestamp
105
+ erb scheduler_template('delayed_timestamp')
106
+ end
107
+
108
+ def delayed_queue_now
109
+ timestamp = params['timestamp'].to_i
110
+ formatted_time = Time.at(timestamp).strftime(
111
+ ::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT
112
+ )
113
+
114
+ if timestamp > 0
115
+ unless ResqueAdmin::Scheduler.enqueue_next_item(timestamp)
116
+ @error_message = "Unable to remove item at #{formatted_time}"
117
+ end
118
+ else
119
+ @error_message = "Incorrect timestamp #{formatted_time}"
120
+ end
121
+
122
+ erb scheduler_template('delayed')
123
+ end
124
+
125
+ def delayed_cancel_now
126
+ klass = ResqueAdmin::Scheduler::Util.constantize(params['klass'])
127
+ timestamp = params['timestamp']
128
+ args = ResqueAdmin.decode params['args']
129
+ ResqueAdmin.remove_delayed_job_from_timestamp(timestamp, klass, *args)
130
+ redirect u('/delayed')
131
+ end
132
+
133
+ def delayed_clear
134
+ ResqueAdmin.reset_delayed_queue
135
+ redirect u('delayed')
136
+ end
137
+ end
138
+
139
+ module HelperMethods
140
+ def format_time(t)
141
+ t.strftime(::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT)
142
+ end
143
+
144
+ def show_job_arguments(args)
145
+ Array(args).map(&:inspect).join("\n")
146
+ end
147
+
148
+ def queue_from_class_name(class_name)
149
+ ResqueAdmin.queue_from_class(
150
+ ResqueAdmin::Scheduler::Util.constantize(class_name)
151
+ )
152
+ end
153
+
154
+ def find_job(worker)
155
+ worker = worker.downcase
156
+ results = working_jobs_for_worker(worker)
157
+
158
+ dels = delayed_jobs_for_worker(worker)
159
+ results += dels.select do |j|
160
+ j['class'].downcase.include?(worker) &&
161
+ j.merge!('where_at' => 'delayed')
162
+ end
163
+
164
+ ResqueAdmin.queues.each do |queue|
165
+ queued = ResqueAdmin.peek(queue, 0, ResqueAdmin.size(queue))
166
+ queued = [queued] unless queued.is_a?(Array)
167
+ results += queued.select do |j|
168
+ j['class'].downcase.include?(worker) &&
169
+ j.merge!('queue' => queue, 'where_at' => 'queued')
170
+ end
171
+ end
172
+
173
+ results
174
+ end
175
+
176
+ def schedule_interval(config)
177
+ if config['every']
178
+ schedule_interval_every(config['every'])
179
+ elsif config['cron']
180
+ 'cron: ' + config['cron'].to_s
181
+ else
182
+ 'Not currently scheduled'
183
+ end
184
+ end
185
+
186
+ def schedule_interval_every(every)
187
+ every = [*every]
188
+ s = 'every: ' << every.first
189
+
190
+ return s unless every.length > 1
191
+
192
+ s << ' ('
193
+ meta = every.last.map do |key, value|
194
+ "#{key.to_s.tr('_', ' ')} #{value}"
195
+ end
196
+ s << meta.join(', ') << ')'
197
+ end
198
+
199
+ def schedule_class(config)
200
+ if config['class'].nil? && !config['custom_job_class'].nil?
201
+ config['custom_job_class']
202
+ else
203
+ config['class']
204
+ end
205
+ end
206
+
207
+ def scheduler_template(name)
208
+ File.read(
209
+ File.expand_path("../server/views/#{name}.erb", __FILE__)
210
+ )
211
+ end
212
+
213
+ def scheduled_in_this_env?(name)
214
+ return true if rails_env(name).nil?
215
+ rails_env(name).split(/[\s,]+/).include?(ResqueAdmin::Scheduler.env)
216
+ end
217
+
218
+ def rails_env(name)
219
+ ResqueAdmin.schedule[name]['rails_env'] || ResqueAdmin.schedule[name]['env']
220
+ end
221
+
222
+ def scheduler_view(filename, options = {}, locals = {})
223
+ source = File.read(File.join(VIEW_PATH, "#{filename}.erb"))
224
+ erb source, options, locals
225
+ end
226
+
227
+ private
228
+
229
+ def working_jobs_for_worker(worker)
230
+ [].tap do |results|
231
+ working = [*ResqueAdmin.working]
232
+ work = working.select do |w|
233
+ w.job && w.job['payload'] &&
234
+ w.job['payload']['class'].downcase.include?(worker)
235
+ end
236
+ work.each do |w|
237
+ results += [
238
+ w.job['payload'].merge(
239
+ 'queue' => w.job['queue'], 'where_at' => 'working'
240
+ )
241
+ ]
242
+ end
243
+ end
244
+ end
245
+
246
+ def delayed_jobs_for_worker(_worker)
247
+ [].tap do |dels|
248
+ schedule_size = ResqueAdmin.delayed_queue_schedule_size
249
+ ResqueAdmin.delayed_queue_peek(0, schedule_size).each do |d|
250
+ ResqueAdmin.delayed_timestamp_peek(
251
+ d, 0, ResqueAdmin.delayed_timestamp_size(d)
252
+ ).each do |j|
253
+ dels << j.merge!('timestamp' => d)
254
+ end
255
+ end
256
+ end
257
+ end
258
+ end
259
+ end
260
+ end
261
+ end
262
+
263
+ ResqueAdmin::Server.tabs << 'Schedule'
264
+ ResqueAdmin::Server.tabs << 'Delayed'
265
+
266
+ ResqueAdmin::Server.class_eval do
267
+ include ResqueAdmin::Scheduler::Server
268
+ end
@@ -0,0 +1,40 @@
1
+ # vim:fileencoding=utf-8
2
+
3
+ module ResqueAdmin
4
+ module Scheduler
5
+ module SignalHandling
6
+ attr_writer :signal_queue
7
+
8
+ def signal_queue
9
+ @signal_queue ||= []
10
+ end
11
+
12
+ # For all signals, set the shutdown flag and wait for current
13
+ # poll/enqueing to finish (should be almost instant). In the
14
+ # case of sleeping, exit immediately.
15
+ def register_signal_handlers
16
+ (Signal.list.keys & %w(INT TERM USR1 USR2 QUIT)).each do |sig|
17
+ trap(sig) do
18
+ signal_queue << sig
19
+ # break sleep in the primary scheduler thread, alowing
20
+ # the signal queue to get processed as soon as possible.
21
+ @th.wakeup if @th && @th.alive?
22
+ end
23
+ end
24
+ end
25
+
26
+ def handle_signals
27
+ loop do
28
+ sig = signal_queue.shift
29
+ break unless sig
30
+ log! "Got #{sig} signal"
31
+ case sig
32
+ when 'INT', 'TERM', 'QUIT' then shutdown
33
+ when 'USR1' then print_schedule
34
+ when 'USR2' then reload_schedule!
35
+ end
36
+ end
37
+ end
38
+ end
39
+ end
40
+ end
@@ -0,0 +1,25 @@
1
+ # vim:fileencoding=utf-8
2
+
3
+ require 'resque_admin/tasks'
4
+ require 'resque_admin-scheduler'
5
+
6
+ namespace :resque_admin do
7
+ task :setup
8
+
9
+ def scheduler_cli
10
+ @scheduler_cli ||= ResqueAdmin::Scheduler::Cli.new(
11
+ %W(#{ENV['RESQUE_SCHEDULER_OPTIONS']})
12
+ )
13
+ end
14
+
15
+ desc 'Start ResqueAdmin Scheduler'
16
+ task scheduler: :scheduler_setup do
17
+ scheduler_cli.setup_env
18
+ scheduler_cli.run_forever
19
+ end
20
+
21
+ task :scheduler_setup do
22
+ scheduler_cli.parse_options
23
+ Rake::Task['resque_admin:setup'].invoke unless scheduler_cli.pre_setup
24
+ end
25
+ end
@@ -0,0 +1,39 @@
1
+ # vim:fileencoding=utf-8
2
+
3
+ module ResqueAdmin
4
+ module Scheduler
5
+ class Util
6
+ # In order to upgrade to resque_admin(1.25) which has deprecated following
7
+ # methods, we just added these usefull helpers back to use in ResqueAdmin
8
+ # Scheduler. refer to:
9
+ # https://github.com/resque_admin/resque_admin-scheduler/pull/273
10
+
11
+ def self.constantize(camel_cased_word)
12
+ camel_cased_word = camel_cased_word.to_s
13
+
14
+ if camel_cased_word.include?('-')
15
+ camel_cased_word = classify(camel_cased_word)
16
+ end
17
+
18
+ names = camel_cased_word.split('::')
19
+ names.shift if names.empty? || names.first.empty?
20
+
21
+ constant = Object
22
+ names.each do |name|
23
+ args = Module.method(:const_get).arity != 1 ? [false] : []
24
+
25
+ constant = if constant.const_defined?(name, *args)
26
+ constant.const_get(name)
27
+ else
28
+ constant.const_missing(name)
29
+ end
30
+ end
31
+ constant
32
+ end
33
+
34
+ def self.classify(dashed_word)
35
+ dashed_word.split('-').map(&:capitalize).join
36
+ end
37
+ end
38
+ end
39
+ end
@@ -1,7 +1,7 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
- module Resque
3
+ module ResqueAdmin
4
4
  module Scheduler
5
- VERSION = '1.0.2'.freeze
5
+ VERSION = '1.3.0'.freeze
6
6
  end
7
7
  end
@@ -7,18 +7,18 @@ require_relative 'scheduler/logger_builder'
7
7
  require_relative 'scheduler/signal_handling'
8
8
  require_relative 'scheduler/failure_handler'
9
9
 
10
- module Resque
10
+ module ResqueAdmin
11
11
  module Scheduler
12
- autoload :Cli, 'resque/scheduler/cli'
13
- autoload :Extension, 'resque/scheduler/extension'
14
- autoload :Util, 'resque/scheduler/util'
15
- autoload :VERSION, 'resque/scheduler/version'
12
+ autoload :Cli, 'resque_admin/scheduler/cli'
13
+ autoload :Extension, 'resque_admin/scheduler/extension'
14
+ autoload :Util, 'resque_admin/scheduler/util'
15
+ autoload :VERSION, 'resque_admin/scheduler/version'
16
16
 
17
17
  private
18
18
 
19
- extend Resque::Scheduler::Locking
20
- extend Resque::Scheduler::Configuration
21
- extend Resque::Scheduler::SignalHandling
19
+ extend ResqueAdmin::Scheduler::Locking
20
+ extend ResqueAdmin::Scheduler::Configuration
21
+ extend ResqueAdmin::Scheduler::SignalHandling
22
22
 
23
23
  public
24
24
 
@@ -38,8 +38,8 @@ module Resque
38
38
  # trap signals
39
39
  register_signal_handlers
40
40
 
41
- # Quote from the resque/worker.
42
- # Fix buffering so we can `rake resque:scheduler > scheduler.log` and
41
+ # Quote from the resque_admin/worker.
42
+ # Fix buffering so we can `rake resque_admin:scheduler > scheduler.log` and
43
43
  # get output from the child in there.
44
44
  $stdout.sync = true
45
45
  $stderr.sync = true
@@ -84,22 +84,22 @@ module Resque
84
84
  end
85
85
  end
86
86
 
87
- # Pulls the schedule from Resque.schedule and loads it into the
87
+ # Pulls the schedule from ResqueAdmin.schedule and loads it into the
88
88
  # rufus scheduler instance
89
89
  def load_schedule!
90
90
  procline 'Loading Schedule'
91
91
 
92
92
  # Need to load the schedule from redis for the first time if dynamic
93
- Resque.reload_schedule! if dynamic
93
+ ResqueAdmin.reload_schedule! if dynamic
94
94
 
95
- log! 'Schedule empty! Set Resque.schedule' if Resque.schedule.empty?
95
+ log! 'Schedule empty! Set ResqueAdmin.schedule' if ResqueAdmin.schedule.empty?
96
96
 
97
97
  @scheduled_jobs = {}
98
98
 
99
- Resque.schedule.each do |name, config|
99
+ ResqueAdmin.schedule.each do |name, config|
100
100
  load_schedule_job(name, config)
101
101
  end
102
- Resque.redis.del(:schedules_changed)
102
+ ResqueAdmin.redis.del(:schedules_changed)
103
103
  procline 'Schedules Loaded'
104
104
  end
105
105
 
@@ -125,9 +125,9 @@ module Resque
125
125
  # in @scheduled_jobs
126
126
  def load_schedule_job(name, config)
127
127
  # If `rails_env` or `env` is set in the config, load jobs only if they
128
- # are meant to be loaded in `Resque::Scheduler.env`. If `rails_env` or
128
+ # are meant to be loaded in `ResqueAdmin::Scheduler.env`. If `rails_env` or
129
129
  # `env` is missing, the job should be scheduled regardless of the value
130
- # of `Resque::Scheduler.env`.
130
+ # of `ResqueAdmin::Scheduler.env`.
131
131
 
132
132
  configured_env = config['rails_env'] || config['env']
133
133
 
@@ -160,8 +160,8 @@ module Resque
160
160
 
161
161
  # Returns true if the given schedule config hash matches the current env
162
162
  def rails_env_matches?(config)
163
- warn '`Resque::Scheduler.rails_env_matches?` is deprecated. ' \
164
- 'Please use `Resque::Scheduler.env_matches?` instead.'
163
+ warn '`ResqueAdmin::Scheduler.rails_env_matches?` is deprecated. ' \
164
+ 'Please use `ResqueAdmin::Scheduler.env_matches?` instead.'
165
165
  config['rails_env'] && env &&
166
166
  config['rails_env'].split(/[\s,]+/).include?(env)
167
167
  end
@@ -175,18 +175,18 @@ module Resque
175
175
  # Handles queueing delayed items
176
176
  # at_time - Time to start scheduling items (default: now).
177
177
  def handle_delayed_items(at_time = nil)
178
- timestamp = Resque.next_delayed_timestamp(at_time)
178
+ timestamp = ResqueAdmin.next_delayed_timestamp(at_time)
179
179
  if timestamp
180
180
  procline 'Processing Delayed Items'
181
181
  until timestamp.nil?
182
182
  enqueue_delayed_items_for_timestamp(timestamp)
183
- timestamp = Resque.next_delayed_timestamp(at_time)
183
+ timestamp = ResqueAdmin.next_delayed_timestamp(at_time)
184
184
  end
185
185
  end
186
186
  end
187
187
 
188
188
  def enqueue_next_item(timestamp)
189
- item = Resque.next_item_for_timestamp(timestamp)
189
+ item = ResqueAdmin.next_item_for_timestamp(timestamp)
190
190
 
191
191
  if item
192
192
  log "queuing #{item['class']} [delayed]"
@@ -213,7 +213,7 @@ module Resque
213
213
  def enqueue(config)
214
214
  enqueue_from_config(config)
215
215
  rescue => e
216
- Resque::Scheduler.failure_handler.on_enqueue_failure(config, e)
216
+ ResqueAdmin::Scheduler.failure_handler.on_enqueue_failure(config, e)
217
217
  end
218
218
 
219
219
  def handle_shutdown
@@ -228,7 +228,7 @@ module Resque
228
228
 
229
229
  klass_name = job_config['class'] || job_config[:class]
230
230
  begin
231
- klass = Resque::Scheduler::Util.constantize(klass_name)
231
+ klass = ResqueAdmin::Scheduler::Util.constantize(klass_name)
232
232
  rescue NameError
233
233
  klass = klass_name
234
234
  end
@@ -236,45 +236,45 @@ module Resque
236
236
  params = args.is_a?(Hash) ? [args] : Array(args)
237
237
  queue = job_config['queue'] ||
238
238
  job_config[:queue] ||
239
- Resque.queue_from_class(klass)
239
+ ResqueAdmin.queue_from_class(klass)
240
240
  # Support custom job classes like those that inherit from
241
- # Resque::JobWithStatus (resque-status)
241
+ # ResqueAdmin::JobWithStatus (resque_admin-status)
242
242
  job_klass = job_config['custom_job_class']
243
- if job_klass && job_klass != 'Resque::Job'
243
+ if job_klass && job_klass != 'ResqueAdmin::Job'
244
244
  # The custom job class API must offer a static "scheduled" method. If
245
245
  # the custom job class can not be constantized (via a requeue call
246
246
  # from the web perhaps), fall back to enqueing normally via
247
- # Resque::Job.create.
247
+ # ResqueAdmin::Job.create.
248
248
  begin
249
- Resque::Scheduler::Util.constantize(job_klass).scheduled(
249
+ ResqueAdmin::Scheduler::Util.constantize(job_klass).scheduled(
250
250
  queue, klass_name, *params
251
251
  )
252
252
  rescue NameError
253
253
  # Note that the custom job class (job_config['custom_job_class'])
254
254
  # is the one enqueued
255
- Resque::Job.create(queue, job_klass, *params)
255
+ ResqueAdmin::Job.create(queue, job_klass, *params)
256
256
  end
257
257
  else
258
258
  # Hack to avoid havoc for people shoving stuff into queues
259
259
  # for non-existent classes (for example: running scheduler in
260
260
  # one app that schedules for another.
261
261
  if Class === klass
262
- Resque::Scheduler::Plugin.run_before_delayed_enqueue_hooks(
262
+ ResqueAdmin::Scheduler::Plugin.run_before_delayed_enqueue_hooks(
263
263
  klass, *params
264
264
  )
265
265
 
266
266
  # If the class is a custom job class, call self#scheduled on it.
267
- # This allows you to do things like Resque.enqueue_at(timestamp,
268
- # CustomJobClass). Otherwise, pass off to Resque.
267
+ # This allows you to do things like ResqueAdmin.enqueue_at(timestamp,
268
+ # CustomJobClass). Otherwise, pass off to ResqueAdmin.
269
269
  if klass.respond_to?(:scheduled)
270
270
  klass.scheduled(queue, klass_name, *params)
271
271
  else
272
- Resque.enqueue_to(queue, klass, *params)
272
+ ResqueAdmin.enqueue_to(queue, klass, *params)
273
273
  end
274
274
  else
275
275
  # This will not run the before_hooks in rescue, but will at least
276
276
  # queue the job.
277
- Resque::Job.create(queue, klass, *params)
277
+ ResqueAdmin::Job.create(queue, klass, *params)
278
278
  end
279
279
  end
280
280
  end
@@ -299,15 +299,15 @@ module Resque
299
299
  end
300
300
 
301
301
  def update_schedule
302
- if Resque.redis.scard(:schedules_changed) > 0
302
+ if ResqueAdmin.redis.scard(:schedules_changed) > 0
303
303
  procline 'Updating schedule'
304
304
  loop do
305
- schedule_name = Resque.redis.spop(:schedules_changed)
305
+ schedule_name = ResqueAdmin.redis.spop(:schedules_changed)
306
306
  break unless schedule_name
307
- Resque.reload_schedule!
308
- if Resque.schedule.keys.include?(schedule_name)
307
+ ResqueAdmin.reload_schedule!
308
+ if ResqueAdmin.schedule.keys.include?(schedule_name)
309
309
  unschedule_job(schedule_name)
310
- load_schedule_job(schedule_name, Resque.schedule[schedule_name])
310
+ load_schedule_job(schedule_name, ResqueAdmin.schedule[schedule_name])
311
311
  else
312
312
  unschedule_job(schedule_name)
313
313
  end
@@ -405,11 +405,11 @@ module Resque
405
405
  end
406
406
 
407
407
  def failure_handler
408
- @failure_handler ||= Resque::Scheduler::FailureHandler
408
+ @failure_handler ||= ResqueAdmin::Scheduler::FailureHandler
409
409
  end
410
410
 
411
411
  def logger
412
- @logger ||= Resque::Scheduler::LoggerBuilder.new(
412
+ @logger ||= ResqueAdmin::Scheduler::LoggerBuilder.new(
413
413
  quiet: quiet,
414
414
  verbose: verbose,
415
415
  log_dev: logfile,
@@ -422,7 +422,7 @@ module Resque
422
422
  def enqueue_recurring(name, config)
423
423
  if master?
424
424
  log! "queueing #{config['class']} (#{name})"
425
- Resque.last_enqueued_at(name, Time.now.to_s)
425
+ ResqueAdmin.last_enqueued_at(name, Time.now.to_s)
426
426
  enqueue(config)
427
427
  end
428
428
  end
@@ -440,7 +440,7 @@ module Resque
440
440
  end
441
441
 
442
442
  def internal_name
443
- "resque-scheduler-#{Resque::Scheduler::VERSION}"
443
+ "resque_admin-scheduler-#{ResqueAdmin::Scheduler::VERSION}"
444
444
  end
445
445
  end
446
446
  end
@@ -0,0 +1,2 @@
1
+ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
2
+ require 'resque_admin/scheduler/tasks'