resque_admin-scheduler 1.0.2 → 1.0.3

Sign up to get free protection for your applications and to get access to all the features.
Files changed (33) hide show
  1. checksums.yaml +4 -4
  2. data/bin/migrate_to_timestamps_set.rb +3 -3
  3. data/exe/resque-scheduler +1 -1
  4. data/lib/{resque → resque-admin}/scheduler.rb +42 -42
  5. data/lib/{resque → resque-admin}/scheduler/cli.rb +4 -4
  6. data/lib/{resque → resque-admin}/scheduler/configuration.rb +1 -1
  7. data/lib/{resque → resque-admin}/scheduler/delaying_extensions.rb +12 -12
  8. data/lib/{resque → resque-admin}/scheduler/env.rb +6 -6
  9. data/lib/{resque → resque-admin}/scheduler/extension.rb +1 -1
  10. data/lib/{resque → resque-admin}/scheduler/failure_handler.rb +2 -2
  11. data/lib/{resque → resque-admin}/scheduler/lock.rb +1 -1
  12. data/lib/{resque → resque-admin}/scheduler/lock/base.rb +3 -3
  13. data/lib/{resque → resque-admin}/scheduler/lock/basic.rb +4 -4
  14. data/lib/{resque → resque-admin}/scheduler/lock/resilient.rb +4 -4
  15. data/lib/{resque → resque-admin}/scheduler/locking.rb +5 -5
  16. data/lib/{resque → resque-admin}/scheduler/logger_builder.rb +2 -2
  17. data/lib/{resque → resque-admin}/scheduler/plugin.rb +1 -1
  18. data/lib/{resque → resque-admin}/scheduler/scheduling_extensions.rb +2 -2
  19. data/lib/{resque → resque-admin}/scheduler/server.rb +35 -35
  20. data/lib/{resque → resque-admin}/scheduler/server/views/delayed.erb +0 -0
  21. data/lib/{resque → resque-admin}/scheduler/server/views/delayed_schedules.erb +0 -0
  22. data/lib/{resque → resque-admin}/scheduler/server/views/delayed_timestamp.erb +0 -0
  23. data/lib/{resque → resque-admin}/scheduler/server/views/requeue-params.erb +0 -0
  24. data/lib/{resque → resque-admin}/scheduler/server/views/scheduler.erb +7 -7
  25. data/lib/{resque → resque-admin}/scheduler/server/views/search.erb +1 -1
  26. data/lib/{resque → resque-admin}/scheduler/server/views/search_form.erb +0 -0
  27. data/lib/{resque → resque-admin}/scheduler/signal_handling.rb +1 -1
  28. data/lib/{resque → resque-admin}/scheduler/tasks.rb +3 -3
  29. data/lib/{resque → resque-admin}/scheduler/util.rb +2 -2
  30. data/lib/{resque → resque-admin}/scheduler/version.rb +2 -2
  31. data/lib/resque-scheduler.rb +2 -2
  32. data/tasks/resque_scheduler.rake +1 -1
  33. metadata +31 -31
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 83fb3060f37567bbac36efc8d64683923baf1b70
4
- data.tar.gz: 01c979171925bc30bf9b8da0382be4475c05af57
3
+ metadata.gz: b9d942201a18e355765e7215ec4421c1439d5562
4
+ data.tar.gz: 5256fe4e2f72e0112f151bb37a6b7d90ec12633c
5
5
  SHA512:
6
- metadata.gz: 526b7495929677d616da2b911a077d29bad088bbc1f53e87764e506e50c17ccbbd3f19c8cd7abc04f7057d8aa5867195a5a8dbe1f0c3591a6e066f344791f525
7
- data.tar.gz: 0a94955015dd3b188659c81ccac304690741ae2516fa72dd7829c15c745f520de0f791dcaa98ddae522552e4946a036901a7d0df4fead3d8aceabc824cd786a6
6
+ metadata.gz: 109e664aad594f9b3354c37f139b0df2d11b7aed24394f7bc957c6f93619e89ea926fd747c5028a13bbefaea7ad69c0e6c454c56d2e16c53484873b9c737eebf
7
+ data.tar.gz: 3896b74f034bb34754bbc4d27cadfb8c28047c54bc0b7fc4310c71a959e31542d080ff8db20eaa9fc7174879a391c57a49887f7ac341a1efbc51d1aafe4ddc97
@@ -1,15 +1,15 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
3
  require 'redis'
4
- require 'resque'
4
+ require 'resque-admin'
5
5
 
6
6
  if ARGV.size != 1
7
7
  puts 'migrate_to_timestamps_set.rb <redis-host:redis-port>'
8
8
  exit
9
9
  end
10
10
 
11
- Resque.redis = ARGV[0]
12
- redis = Resque.redis
11
+ ResqueAdmin.redis = ARGV[0]
12
+ redis = ResqueAdmin.redis
13
13
  Array(redis.keys('delayed:*')).each do |key|
14
14
  jobs = redis.lrange(key, 0, -1)
15
15
  jobs.each { |job| redis.sadd("timestamps:#{job}", key) }
data/exe/resque-scheduler CHANGED
@@ -2,4 +2,4 @@
2
2
  # vim:fileencoding=utf-8
3
3
 
4
4
  require 'resque-scheduler'
5
- Resque::Scheduler::Cli.run!
5
+ ResqueAdmin::Scheduler::Cli.run!
@@ -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
 
@@ -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-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-scheduler-#{ResqueAdmin::Scheduler::VERSION}"
444
444
  end
445
445
  end
446
446
  end
@@ -2,7 +2,7 @@
2
2
 
3
3
  require 'optparse'
4
4
 
5
- module Resque
5
+ module ResqueAdmin
6
6
  module Scheduler
7
7
  CLI_OPTIONS_ENV_MAPPING = {
8
8
  app_name: 'APP_NAME',
@@ -114,7 +114,7 @@ module Resque
114
114
  end
115
115
 
116
116
  def run_forever
117
- Resque::Scheduler.run
117
+ ResqueAdmin::Scheduler.run
118
118
  end
119
119
 
120
120
  private
@@ -122,13 +122,13 @@ module Resque
122
122
  attr_reader :argv, :env
123
123
 
124
124
  def runtime_env
125
- @runtime_env ||= Resque::Scheduler::Env.new(options)
125
+ @runtime_env ||= ResqueAdmin::Scheduler::Env.new(options)
126
126
  end
127
127
 
128
128
  def option_parser
129
129
  OptionParser.new do |opts|
130
130
  opts.banner = BANNER
131
- opts.version = Resque::Scheduler::VERSION
131
+ opts.version = ResqueAdmin::Scheduler::VERSION
132
132
  OPTIONS.each do |opt|
133
133
  opts.on(*opt[:args], &opt[:callback].call(options))
134
134
  end
@@ -1,6 +1,6 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
- module Resque
3
+ module ResqueAdmin
4
4
  module Scheduler
5
5
  module Configuration
6
6
  # Allows for block-style configuration
@@ -3,7 +3,7 @@ require 'resque'
3
3
  require_relative 'plugin'
4
4
  require_relative '../scheduler'
5
5
 
6
- module Resque
6
+ module ResqueAdmin
7
7
  module Scheduler
8
8
  module DelayingExtensions
9
9
  # This method is nearly identical to +enqueue+ only it also
@@ -19,21 +19,21 @@ module Resque
19
19
 
20
20
  # Identical to +enqueue_at+, except you can also specify
21
21
  # a queue in which the job will be placed after the
22
- # timestamp has passed. It respects Resque.inline option, by
22
+ # timestamp has passed. It respects ResqueAdmin.inline option, by
23
23
  # creating the job right away instead of adding to the queue.
24
24
  def enqueue_at_with_queue(queue, timestamp, klass, *args)
25
25
  return false unless plugin.run_before_schedule_hooks(klass, *args)
26
26
 
27
- if Resque.inline? || timestamp.to_i < Time.now.to_i
27
+ if ResqueAdmin.inline? || timestamp.to_i < Time.now.to_i
28
28
  # Just create the job and let resque perform it right away with
29
29
  # inline. If the class is a custom job class, call self#scheduled
30
30
  # on it. This allows you to do things like
31
- # Resque.enqueue_at(timestamp, CustomJobClass, :opt1 => val1).
32
- # Otherwise, pass off to Resque.
31
+ # ResqueAdmin.enqueue_at(timestamp, CustomJobClass, :opt1 => val1).
32
+ # Otherwise, pass off to ResqueAdmin.
33
33
  if klass.respond_to?(:scheduled)
34
34
  klass.scheduled(queue, klass.to_s, *args)
35
35
  else
36
- Resque::Job.create(queue, klass, *args)
36
+ ResqueAdmin::Job.create(queue, klass, *args)
37
37
  end
38
38
  else
39
39
  delayed_push(timestamp, job_to_hash_with_queue(queue, klass, args))
@@ -147,7 +147,7 @@ module Resque
147
147
  def enqueue_delayed(klass, *args)
148
148
  hash = job_to_hash(klass, args)
149
149
  remove_delayed(klass, *args).times do
150
- Resque::Scheduler.enqueue_from_config(hash)
150
+ ResqueAdmin::Scheduler.enqueue_from_config(hash)
151
151
  end
152
152
  end
153
153
 
@@ -210,7 +210,7 @@ module Resque
210
210
  # O(N) where N is the number of jobs scheduled to fire at the given
211
211
  # timestamp
212
212
  def remove_delayed_job_from_timestamp(timestamp, klass, *args)
213
- return 0 if Resque.inline?
213
+ return 0 if ResqueAdmin.inline?
214
214
 
215
215
  key = "delayed:#{timestamp.to_i}"
216
216
  encoded_job = encode(job_to_hash(klass, args))
@@ -232,8 +232,8 @@ module Resque
232
232
 
233
233
  # Discover if a job has been delayed.
234
234
  # Examples
235
- # Resque.delayed?(MyJob)
236
- # Resque.delayed?(MyJob, id: 1)
235
+ # ResqueAdmin.delayed?(MyJob)
236
+ # ResqueAdmin.delayed?(MyJob, id: 1)
237
237
  # Returns true if the job has been delayed
238
238
  def delayed?(klass, *args)
239
239
  !scheduled_at(klass, *args).empty?
@@ -266,7 +266,7 @@ module Resque
266
266
  end
267
267
 
268
268
  def remove_delayed_job(encoded_job)
269
- return 0 if Resque.inline?
269
+ return 0 if ResqueAdmin.inline?
270
270
 
271
271
  timestamps = redis.smembers("timestamps:#{encoded_job}")
272
272
 
@@ -317,7 +317,7 @@ module Resque
317
317
  end
318
318
 
319
319
  def plugin
320
- Resque::Scheduler::Plugin
320
+ ResqueAdmin::Scheduler::Plugin
321
321
  end
322
322
  end
323
323
  end
@@ -2,7 +2,7 @@
2
2
 
3
3
  require 'English' # $PROCESS_ID
4
4
 
5
- module Resque
5
+ module ResqueAdmin
6
6
  module Scheduler
7
7
  class Env
8
8
  def initialize(options)
@@ -12,7 +12,7 @@ module Resque
12
12
 
13
13
  def setup
14
14
  require 'resque'
15
- require 'resque/scheduler'
15
+ require 'resque-admin/scheduler'
16
16
 
17
17
  setup_backgrounding
18
18
  setup_pid_file
@@ -32,7 +32,7 @@ module Resque
32
32
 
33
33
  # Need to set this here for conditional Process.daemon redirect of
34
34
  # stderr/stdout to /dev/null
35
- Resque::Scheduler.quiet = if options.key?(:quiet)
35
+ ResqueAdmin::Scheduler.quiet = if options.key?(:quiet)
36
36
  !!options[:quiet]
37
37
  else
38
38
  true
@@ -42,8 +42,8 @@ module Resque
42
42
  abort 'background option is set, which requires ruby >= 1.9'
43
43
  end
44
44
 
45
- Process.daemon(true, !Resque::Scheduler.quiet)
46
- Resque.redis.client.reconnect
45
+ Process.daemon(true, !ResqueAdmin::Scheduler.quiet)
46
+ ResqueAdmin.redis.client.reconnect
47
47
  end
48
48
 
49
49
  def setup_pid_file
@@ -59,7 +59,7 @@ module Resque
59
59
  end
60
60
 
61
61
  def setup_scheduler_configuration
62
- Resque::Scheduler.configure do |c|
62
+ ResqueAdmin::Scheduler.configure do |c|
63
63
  c.app_name = options[:app_name] if options.key?(:app_name)
64
64
 
65
65
  c.dynamic = !!options[:dynamic] if options.key?(:dynamic)
@@ -3,7 +3,7 @@
3
3
  require_relative 'scheduling_extensions'
4
4
  require_relative 'delaying_extensions'
5
5
 
6
- module Resque
6
+ module ResqueAdmin
7
7
  module Scheduler
8
8
  module Extension
9
9
  include SchedulingExtensions
@@ -1,8 +1,8 @@
1
- module Resque
1
+ module ResqueAdmin
2
2
  module Scheduler
3
3
  class FailureHandler
4
4
  def self.on_enqueue_failure(_, e)
5
- Resque::Scheduler.log_error(
5
+ ResqueAdmin::Scheduler.log_error(
6
6
  "#{e.class.name}: #{e.message} #{e.backtrace.inspect}"
7
7
  )
8
8
  end
@@ -1,4 +1,4 @@
1
1
  # vim:fileencoding=utf-8
2
2
  %w(base basic resilient).each do |file|
3
- require "resque/scheduler/lock/#{file}"
3
+ require "resque-admin/scheduler/lock/#{file}"
4
4
  end
@@ -1,6 +1,6 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
- module Resque
3
+ module ResqueAdmin
4
4
  module Scheduler
5
5
  module Lock
6
6
  class Base
@@ -30,7 +30,7 @@ module Resque
30
30
 
31
31
  # Releases the lock.
32
32
  def release!
33
- Resque.redis.del(key) == 1
33
+ ResqueAdmin.redis.del(key) == 1
34
34
  end
35
35
 
36
36
  # Releases the lock iff we own it
@@ -42,7 +42,7 @@ module Resque
42
42
 
43
43
  # Extends the lock by `timeout` seconds.
44
44
  def extend_lock!
45
- Resque.redis.expire(key, timeout)
45
+ ResqueAdmin.redis.expire(key, timeout)
46
46
  end
47
47
 
48
48
  def hostname
@@ -1,22 +1,22 @@
1
1
  # vim:fileencoding=utf-8
2
2
  require_relative 'base'
3
3
 
4
- module Resque
4
+ module ResqueAdmin
5
5
  module Scheduler
6
6
  module Lock
7
7
  class Basic < Base
8
8
  def acquire!
9
- if Resque.redis.setnx(key, value)
9
+ if ResqueAdmin.redis.setnx(key, value)
10
10
  extend_lock!
11
11
  true
12
12
  end
13
13
  end
14
14
 
15
15
  def locked?
16
- if Resque.redis.get(key) == value
16
+ if ResqueAdmin.redis.get(key) == value
17
17
  extend_lock!
18
18
 
19
- return true if Resque.redis.get(key) == value
19
+ return true if ResqueAdmin.redis.get(key) == value
20
20
  end
21
21
 
22
22
  false
@@ -1,7 +1,7 @@
1
1
  # vim:fileencoding=utf-8
2
2
  require_relative 'base'
3
3
 
4
- module Resque
4
+ module ResqueAdmin
5
5
  module Scheduler
6
6
  module Lock
7
7
  class Resilient < Base
@@ -26,7 +26,7 @@ module Resque
26
26
 
27
27
  def evalsha(script, keys, argv, refresh: false)
28
28
  sha_method_name = "#{script}_sha"
29
- Resque.redis.evalsha(
29
+ ResqueAdmin.redis.evalsha(
30
30
  send(sha_method_name, refresh),
31
31
  keys: keys,
32
32
  argv: argv
@@ -43,7 +43,7 @@ module Resque
43
43
  @locked_sha = nil if refresh
44
44
 
45
45
  @locked_sha ||=
46
- Resque.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
46
+ ResqueAdmin.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
47
47
  if redis.call('GET', KEYS[1]) == ARGV[1]
48
48
  then
49
49
  redis.call('EXPIRE', KEYS[1], #{timeout})
@@ -62,7 +62,7 @@ module Resque
62
62
  @acquire_sha = nil if refresh
63
63
 
64
64
  @acquire_sha ||=
65
- Resque.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
65
+ ResqueAdmin.redis.script(:load, <<-EOF.gsub(/^ {14}/, ''))
66
66
  if redis.call('SETNX', KEYS[1], ARGV[1]) == 1
67
67
  then
68
68
  redis.call('EXPIRE', KEYS[1], #{timeout})
@@ -51,7 +51,7 @@
51
51
 
52
52
  require_relative 'lock'
53
53
 
54
- module Resque
54
+ module ResqueAdmin
55
55
  module Scheduler
56
56
  module Locking
57
57
  def master_lock
@@ -84,20 +84,20 @@ module Resque
84
84
 
85
85
  def build_master_lock
86
86
  if supports_lua?
87
- Resque::Scheduler::Lock::Resilient.new(master_lock_key)
87
+ ResqueAdmin::Scheduler::Lock::Resilient.new(master_lock_key)
88
88
  else
89
- Resque::Scheduler::Lock::Basic.new(master_lock_key)
89
+ ResqueAdmin::Scheduler::Lock::Basic.new(master_lock_key)
90
90
  end
91
91
  end
92
92
 
93
93
  def master_lock_key
94
94
  lock_prefix = ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] || ''
95
95
  lock_prefix += ':' if lock_prefix != ''
96
- "#{Resque.redis.namespace}:#{lock_prefix}resque_scheduler_master_lock"
96
+ "#{ResqueAdmin.redis.namespace}:#{lock_prefix}resque_scheduler_master_lock"
97
97
  end
98
98
 
99
99
  def redis_master_version
100
- Resque.redis.info['redis_version'].to_f
100
+ ResqueAdmin.redis.info['redis_version'].to_f
101
101
  end
102
102
  end
103
103
  end
@@ -2,12 +2,12 @@
2
2
 
3
3
  require 'mono_logger'
4
4
 
5
- module Resque
5
+ module ResqueAdmin
6
6
  module Scheduler
7
7
  # Just builds a logger, with specified verbosity and destination.
8
8
  # The simplest example:
9
9
  #
10
- # Resque::Scheduler::LoggerBuilder.new.build
10
+ # ResqueAdmin::Scheduler::LoggerBuilder.new.build
11
11
  class LoggerBuilder
12
12
  # Initializes new instance of the builder
13
13
  #
@@ -1,6 +1,6 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
- module Resque
3
+ module ResqueAdmin
4
4
  module Scheduler
5
5
  module Plugin
6
6
  def self.hooks(job, pattern)
@@ -1,6 +1,6 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
- module Resque
3
+ module ResqueAdmin
4
4
  module Scheduler
5
5
  module SchedulingExtensions
6
6
  # Accepts a new schedule configuration of the form:
@@ -76,7 +76,7 @@ module Resque
76
76
  # Note: values for class and custom_job_class need to be strings,
77
77
  # not constants.
78
78
  #
79
- # Resque.set_schedule('some_job', {:class => 'SomeJob',
79
+ # ResqueAdmin.set_schedule('some_job', {:class => 'SomeJob',
80
80
  # :every => '15mins',
81
81
  # :queue => 'high',
82
82
  # :args => '/tmp/poop'})
@@ -1,16 +1,16 @@
1
1
  # vim:fileencoding=utf-8
2
2
  require 'resque-scheduler'
3
- require 'resque/server'
3
+ require 'resque-admin/server'
4
4
  require 'tilt/erb'
5
5
  require 'json'
6
6
 
7
- # Extend Resque::Server to add tabs
8
- module Resque
7
+ # Extend ResqueAdmin::Server to add tabs
8
+ module ResqueAdmin
9
9
  module Scheduler
10
10
  module Server
11
11
  TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S %z'.freeze
12
12
 
13
- unless defined?(::Resque::Scheduler::Server::VIEW_PATH)
13
+ unless defined?(::ResqueAdmin::Scheduler::Server::VIEW_PATH)
14
14
  VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
15
15
  end
16
16
 
@@ -37,25 +37,25 @@ module Resque
37
37
 
38
38
  module ServerMethods
39
39
  def schedule
40
- Resque.reload_schedule! if Resque::Scheduler.dynamic
40
+ ResqueAdmin.reload_schedule! if ResqueAdmin::Scheduler.dynamic
41
41
  erb scheduler_template('scheduler')
42
42
  end
43
43
 
44
44
  def schedule_requeue
45
45
  @job_name = params['job_name'] || params[:job_name]
46
- config = Resque.schedule[@job_name]
46
+ config = ResqueAdmin.schedule[@job_name]
47
47
  @parameters = config['parameters'] || config[:parameters]
48
48
  if @parameters
49
49
  erb scheduler_template('requeue-params')
50
50
  else
51
- Resque::Scheduler.enqueue_from_config(config)
51
+ ResqueAdmin::Scheduler.enqueue_from_config(config)
52
52
  redirect u('/overview')
53
53
  end
54
54
  end
55
55
 
56
56
  def schedule_requeue_with_params
57
57
  job_name = params['job_name'] || params[:job_name]
58
- config = Resque.schedule[job_name]
58
+ config = ResqueAdmin.schedule[job_name]
59
59
  # Build args hash from post data (removing the job name)
60
60
  submitted_args = params.reject do |key, _value|
61
61
  key == 'job_name' || key == :job_name
@@ -68,14 +68,14 @@ module Resque
68
68
 
69
69
  # Insert the args hash into config and queue the resque job
70
70
  config = config.merge('args' => config_args)
71
- Resque::Scheduler.enqueue_from_config(config)
71
+ ResqueAdmin::Scheduler.enqueue_from_config(config)
72
72
  redirect u('/overview')
73
73
  end
74
74
 
75
75
  def delete_schedule
76
- if Resque::Scheduler.dynamic
76
+ if ResqueAdmin::Scheduler.dynamic
77
77
  job_name = params['job_name'] || params[:job_name]
78
- Resque.remove_schedule(job_name)
78
+ ResqueAdmin.remove_schedule(job_name)
79
79
  end
80
80
  redirect u('/schedule')
81
81
  end
@@ -86,9 +86,9 @@ module Resque
86
86
 
87
87
  def delayed_jobs_klass
88
88
  begin
89
- klass = Resque::Scheduler::Util.constantize(params[:klass])
89
+ klass = ResqueAdmin::Scheduler::Util.constantize(params[:klass])
90
90
  @args = JSON.load(URI.decode(params[:args]))
91
- @timestamps = Resque.scheduled_at(klass, *@args)
91
+ @timestamps = ResqueAdmin.scheduled_at(klass, *@args)
92
92
  rescue
93
93
  @timestamps = []
94
94
  end
@@ -108,11 +108,11 @@ module Resque
108
108
  def delayed_queue_now
109
109
  timestamp = params['timestamp'].to_i
110
110
  formatted_time = Time.at(timestamp).strftime(
111
- ::Resque::Scheduler::Server::TIMESTAMP_FORMAT
111
+ ::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT
112
112
  )
113
113
 
114
114
  if timestamp > 0
115
- unless Resque::Scheduler.enqueue_next_item(timestamp)
115
+ unless ResqueAdmin::Scheduler.enqueue_next_item(timestamp)
116
116
  @error_message = "Unable to remove item at #{formatted_time}"
117
117
  end
118
118
  else
@@ -123,22 +123,22 @@ module Resque
123
123
  end
124
124
 
125
125
  def delayed_cancel_now
126
- klass = Resque::Scheduler::Util.constantize(params['klass'])
126
+ klass = ResqueAdmin::Scheduler::Util.constantize(params['klass'])
127
127
  timestamp = params['timestamp']
128
- args = Resque.decode params['args']
129
- Resque.remove_delayed_job_from_timestamp(timestamp, klass, *args)
128
+ args = ResqueAdmin.decode params['args']
129
+ ResqueAdmin.remove_delayed_job_from_timestamp(timestamp, klass, *args)
130
130
  redirect u('/delayed')
131
131
  end
132
132
 
133
133
  def delayed_clear
134
- Resque.reset_delayed_queue
134
+ ResqueAdmin.reset_delayed_queue
135
135
  redirect u('delayed')
136
136
  end
137
137
  end
138
138
 
139
139
  module HelperMethods
140
140
  def format_time(t)
141
- t.strftime(::Resque::Scheduler::Server::TIMESTAMP_FORMAT)
141
+ t.strftime(::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT)
142
142
  end
143
143
 
144
144
  def show_job_arguments(args)
@@ -146,8 +146,8 @@ module Resque
146
146
  end
147
147
 
148
148
  def queue_from_class_name(class_name)
149
- Resque.queue_from_class(
150
- Resque::Scheduler::Util.constantize(class_name)
149
+ ResqueAdmin.queue_from_class(
150
+ ResqueAdmin::Scheduler::Util.constantize(class_name)
151
151
  )
152
152
  end
153
153
 
@@ -161,8 +161,8 @@ module Resque
161
161
  j.merge!('where_at' => 'delayed')
162
162
  end
163
163
 
164
- Resque.queues.each do |queue|
165
- queued = Resque.peek(queue, 0, Resque.size(queue))
164
+ ResqueAdmin.queues.each do |queue|
165
+ queued = ResqueAdmin.peek(queue, 0, ResqueAdmin.size(queue))
166
166
  queued = [queued] unless queued.is_a?(Array)
167
167
  results += queued.select do |j|
168
168
  j['class'].downcase.include?(worker) &&
@@ -212,11 +212,11 @@ module Resque
212
212
 
213
213
  def scheduled_in_this_env?(name)
214
214
  return true if rails_env(name).nil?
215
- rails_env(name).split(/[\s,]+/).include?(Resque::Scheduler.env)
215
+ rails_env(name).split(/[\s,]+/).include?(ResqueAdmin::Scheduler.env)
216
216
  end
217
217
 
218
218
  def rails_env(name)
219
- Resque.schedule[name]['rails_env'] || Resque.schedule[name]['env']
219
+ ResqueAdmin.schedule[name]['rails_env'] || ResqueAdmin.schedule[name]['env']
220
220
  end
221
221
 
222
222
  def scheduler_view(filename, options = {}, locals = {})
@@ -228,7 +228,7 @@ module Resque
228
228
 
229
229
  def working_jobs_for_worker(worker)
230
230
  [].tap do |results|
231
- working = [*Resque.working]
231
+ working = [*ResqueAdmin.working]
232
232
  work = working.select do |w|
233
233
  w.job && w.job['payload'] &&
234
234
  w.job['payload']['class'].downcase.include?(worker)
@@ -245,10 +245,10 @@ module Resque
245
245
 
246
246
  def delayed_jobs_for_worker(_worker)
247
247
  [].tap do |dels|
248
- schedule_size = Resque.delayed_queue_schedule_size
249
- Resque.delayed_queue_peek(0, schedule_size).each do |d|
250
- Resque.delayed_timestamp_peek(
251
- d, 0, Resque.delayed_timestamp_size(d)
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
252
  ).each do |j|
253
253
  dels << j.merge!('timestamp' => d)
254
254
  end
@@ -260,9 +260,9 @@ module Resque
260
260
  end
261
261
  end
262
262
 
263
- Resque::Server.tabs << 'Schedule'
264
- Resque::Server.tabs << 'Delayed'
263
+ ResqueAdmin::Server.tabs << 'Schedule'
264
+ ResqueAdmin::Server.tabs << 'Delayed'
265
265
 
266
- Resque::Server.class_eval do
267
- include Resque::Scheduler::Server
266
+ ResqueAdmin::Server.class_eval do
267
+ include ResqueAdmin::Scheduler::Server
268
268
  end
@@ -4,8 +4,8 @@
4
4
  The list below contains all scheduled jobs. Click &quot;Queue now&quot; to queue
5
5
  a job immediately.
6
6
  <br/> Server local time: <%= Time.now %>
7
- <br/> Server Environment: <%= Resque::Scheduler.env %>
8
- <br/> Current master: <%= Resque.redis.get(Resque::Scheduler.master_lock.key) %>
7
+ <br/> Server Environment: <%= ResqueAdmin::Scheduler.env %>
8
+ <br/> Current master: <%= ResqueAdmin.redis.get(ResqueAdmin::Scheduler.master_lock.key) %>
9
9
  </p>
10
10
  <p class='intro'>
11
11
  The highlighted jobs are skipped for current environment.
@@ -14,7 +14,7 @@
14
14
  <table>
15
15
  <tr>
16
16
  <th>Index</th>
17
- <% if Resque::Scheduler.dynamic %>
17
+ <% if ResqueAdmin::Scheduler.dynamic %>
18
18
  <th></th>
19
19
  <% end %>
20
20
  <th></th>
@@ -26,11 +26,11 @@
26
26
  <th>Arguments</th>
27
27
  <th>Last Enqueued</th>
28
28
  </tr>
29
- <% Resque.schedule.keys.sort.each_with_index do |name, index| %>
30
- <% config = Resque.schedule[name] %>
29
+ <% ResqueAdmin.schedule.keys.sort.each_with_index do |name, index| %>
30
+ <% config = ResqueAdmin.schedule[name] %>
31
31
  <tr style="<%= scheduled_in_this_env?(name) ? '' : 'color: #9F6000;background: #FEEFB3;' %>">
32
32
  <td style="padding-left: 15px;"><%= index+ 1 %>.</td>
33
- <% if Resque::Scheduler.dynamic %>
33
+ <% if ResqueAdmin::Scheduler.dynamic %>
34
34
  <td style="padding-top: 12px; padding-bottom: 2px; width: 10px">
35
35
  <form action="<%= u "/schedule" %>" method="post" style="margin-left: 0">
36
36
  <input type="hidden" name="job_name" value="<%= h name %>">
@@ -51,7 +51,7 @@
51
51
  <td><%= h schedule_class(config) %></td>
52
52
  <td><%= h config['queue'] || queue_from_class_name(config['class']) %></td>
53
53
  <td><%= h show_job_arguments(config['args']) %></td>
54
- <td><%= h Resque.get_last_enqueued_at(name) || 'Never' %></td>
54
+ <td><%= h ResqueAdmin.get_last_enqueued_at(name) || 'Never' %></td>
55
55
  </tr>
56
56
  <% end %>
57
57
  </table>
@@ -23,7 +23,7 @@
23
23
  <form action="<%= u "/delayed/cancel_now" %>" method="post">
24
24
  <input type="hidden" name="timestamp" value="<%= job['timestamp'].to_i %>">
25
25
  <input type="hidden" name="klass" value="<%= job['class'] %>">
26
- <input type="hidden" name="args" value="<%= h(Resque.encode job['args']) %>">
26
+ <input type="hidden" name="args" value="<%= h(ResqueAdmin.encode job['args']) %>">
27
27
  <input type="submit" value="Cancel Job">
28
28
  </form>
29
29
  </td>
@@ -1,6 +1,6 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
- module Resque
3
+ module ResqueAdmin
4
4
  module Scheduler
5
5
  module SignalHandling
6
6
  attr_writer :signal_queue
@@ -1,18 +1,18 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
- require 'resque/tasks'
3
+ require 'resque-admin/tasks'
4
4
  require 'resque-scheduler'
5
5
 
6
6
  namespace :resque do
7
7
  task :setup
8
8
 
9
9
  def scheduler_cli
10
- @scheduler_cli ||= Resque::Scheduler::Cli.new(
10
+ @scheduler_cli ||= ResqueAdmin::Scheduler::Cli.new(
11
11
  %W(#{ENV['RESQUE_SCHEDULER_OPTIONS']})
12
12
  )
13
13
  end
14
14
 
15
- desc 'Start Resque Scheduler'
15
+ desc 'Start ResqueAdmin Scheduler'
16
16
  task scheduler: :scheduler_setup do
17
17
  scheduler_cli.setup_env
18
18
  scheduler_cli.run_forever
@@ -1,10 +1,10 @@
1
1
  # vim:fileencoding=utf-8
2
2
 
3
- module Resque
3
+ module ResqueAdmin
4
4
  module Scheduler
5
5
  class Util
6
6
  # In order to upgrade to resque(1.25) which has deprecated following
7
- # methods, we just added these usefull helpers back to use in Resque
7
+ # methods, we just added these usefull helpers back to use in ResqueAdmin
8
8
  # Scheduler. refer to:
9
9
  # https://github.com/resque/resque-scheduler/pull/273
10
10
 
@@ -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.0.3'.freeze
6
6
  end
7
7
  end
@@ -1,4 +1,4 @@
1
1
  # vim:fileencoding=utf-8
2
- require_relative 'resque/scheduler'
2
+ require_relative 'resque-admin/scheduler'
3
3
 
4
- Resque.extend Resque::Scheduler::Extension
4
+ ResqueAdmin.extend ResqueAdmin::Scheduler::Extension
@@ -1,2 +1,2 @@
1
1
  $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
2
- require 'resque/scheduler/tasks'
2
+ require 'resque-admin/scheduler/tasks'
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: resque_admin-scheduler
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.2
4
+ version: 1.0.3
5
5
  platform: ruby
6
6
  authors:
7
7
  - Ben VandenBos
@@ -11,7 +11,7 @@ authors:
11
11
  autorequire:
12
12
  bindir: exe
13
13
  cert_chain: []
14
- date: 2017-09-22 00:00:00.000000000 Z
14
+ date: 2017-10-17 00:00:00.000000000 Z
15
15
  dependencies:
16
16
  - !ruby/object:Gem::Dependency
17
17
  name: bundler
@@ -196,7 +196,7 @@ dependencies:
196
196
  - !ruby/object:Gem::Version
197
197
  version: 0.40.0
198
198
  description: |2
199
- Light weight job scheduling on top of ResqueAdmin.
199
+ Light weight job scheduling on top of ResqueAdminAdmin.
200
200
  Adds methods enqueue_at/enqueue_in to schedule jobs in the future.
201
201
  Also supports queueing jobs on a fixed, cron-like schedule.
202
202
  email:
@@ -211,34 +211,34 @@ extra_rdoc_files: []
211
211
  files:
212
212
  - bin/migrate_to_timestamps_set.rb
213
213
  - exe/resque-scheduler
214
+ - lib/resque-admin/scheduler.rb
215
+ - lib/resque-admin/scheduler/cli.rb
216
+ - lib/resque-admin/scheduler/configuration.rb
217
+ - lib/resque-admin/scheduler/delaying_extensions.rb
218
+ - lib/resque-admin/scheduler/env.rb
219
+ - lib/resque-admin/scheduler/extension.rb
220
+ - lib/resque-admin/scheduler/failure_handler.rb
221
+ - lib/resque-admin/scheduler/lock.rb
222
+ - lib/resque-admin/scheduler/lock/base.rb
223
+ - lib/resque-admin/scheduler/lock/basic.rb
224
+ - lib/resque-admin/scheduler/lock/resilient.rb
225
+ - lib/resque-admin/scheduler/locking.rb
226
+ - lib/resque-admin/scheduler/logger_builder.rb
227
+ - lib/resque-admin/scheduler/plugin.rb
228
+ - lib/resque-admin/scheduler/scheduling_extensions.rb
229
+ - lib/resque-admin/scheduler/server.rb
230
+ - lib/resque-admin/scheduler/server/views/delayed.erb
231
+ - lib/resque-admin/scheduler/server/views/delayed_schedules.erb
232
+ - lib/resque-admin/scheduler/server/views/delayed_timestamp.erb
233
+ - lib/resque-admin/scheduler/server/views/requeue-params.erb
234
+ - lib/resque-admin/scheduler/server/views/scheduler.erb
235
+ - lib/resque-admin/scheduler/server/views/search.erb
236
+ - lib/resque-admin/scheduler/server/views/search_form.erb
237
+ - lib/resque-admin/scheduler/signal_handling.rb
238
+ - lib/resque-admin/scheduler/tasks.rb
239
+ - lib/resque-admin/scheduler/util.rb
240
+ - lib/resque-admin/scheduler/version.rb
214
241
  - lib/resque-scheduler.rb
215
- - lib/resque/scheduler.rb
216
- - lib/resque/scheduler/cli.rb
217
- - lib/resque/scheduler/configuration.rb
218
- - lib/resque/scheduler/delaying_extensions.rb
219
- - lib/resque/scheduler/env.rb
220
- - lib/resque/scheduler/extension.rb
221
- - lib/resque/scheduler/failure_handler.rb
222
- - lib/resque/scheduler/lock.rb
223
- - lib/resque/scheduler/lock/base.rb
224
- - lib/resque/scheduler/lock/basic.rb
225
- - lib/resque/scheduler/lock/resilient.rb
226
- - lib/resque/scheduler/locking.rb
227
- - lib/resque/scheduler/logger_builder.rb
228
- - lib/resque/scheduler/plugin.rb
229
- - lib/resque/scheduler/scheduling_extensions.rb
230
- - lib/resque/scheduler/server.rb
231
- - lib/resque/scheduler/server/views/delayed.erb
232
- - lib/resque/scheduler/server/views/delayed_schedules.erb
233
- - lib/resque/scheduler/server/views/delayed_timestamp.erb
234
- - lib/resque/scheduler/server/views/requeue-params.erb
235
- - lib/resque/scheduler/server/views/scheduler.erb
236
- - lib/resque/scheduler/server/views/search.erb
237
- - lib/resque/scheduler/server/views/search_form.erb
238
- - lib/resque/scheduler/signal_handling.rb
239
- - lib/resque/scheduler/tasks.rb
240
- - lib/resque/scheduler/util.rb
241
- - lib/resque/scheduler/version.rb
242
242
  - tasks/resque_scheduler.rake
243
243
  homepage: http://github.com/resque_admin/resque_admin-scheduler
244
244
  licenses:
@@ -263,5 +263,5 @@ rubyforge_project:
263
263
  rubygems_version: 2.6.10
264
264
  signing_key:
265
265
  specification_version: 4
266
- summary: Light weight job scheduling on top of ResqueAdmin
266
+ summary: Light weight job scheduling on top of ResqueAdminAdmin
267
267
  test_files: []