Module: When

Defined in:
lib/when-do.rb,
lib/when-do/do.rb,
lib/when-do/cli.rb,
lib/when-do/job.rb,
lib/when-do/version.rb

Defined Under Namespace

Classes: CLI, Do, Error, InvalidArgs, InvalidCron, Job

Constant Summary collapse

DEFAULT_CONFIG = 
{
  schedule_key:      'when:schedules',
  worker_queue_key:  'when:queue:default',
  delayed_queue_key: 'when:delayed'
}
VERSION = 
'2.0.2'

Class Method Summary collapse

Class Method Details

.config ⇒ Object 



93
94
95
 
# File 'lib/when-do.rb', line 93

def self.config
  @config ||= DEFAULT_CONFIG
end

.config=(new_config) ⇒ Object 



97
98
99
100
 
# File 'lib/when-do.rb', line 97

def self.config=(new_config)
  logger.info("Resetting config to #{new_config.inspect}") if @config
  @config = new_config
end

.delayed_queue_key ⇒ Object 



119
120
121
 
# File 'lib/when-do.rb', line 119

def self.delayed_queue_key
  config[:delayed_queue_key] || 'when:delayed'
end

.enqueue(klass, args: [], worker_args: {}) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/when-do.rb', line 67

def self.enqueue(klass, args: [], worker_args: {})
  validate_args(args)
  job = worker_args.merge('jid' => SecureRandom.uuid, 'class' => klass.to_s, 'args' => args)
  wqk = job[:queue] || job['queue'] || worker_queue_key
  if redis.lpush(wqk, job.to_json) > 0
    job['jid']
  else
    msg = "Failed to enqueue #{job}."
    logger.fatal(msg)
    raise msg
  end
end

.enqueue_at(time, klass, args: [], worker_args: {}) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/when-do.rb', line 54

def self.enqueue_at(time, klass, args: [], worker_args: {})
  validate_args(args)
  job = worker_args.merge('jid' => SecureRandom.uuid, 'class' => klass.to_s, 'args' => args)
  if redis.zadd(delayed_queue_key, time.to_i, job.to_json)
    logger.info("Delayed: will enqueue #{job} to run at #{time}.")
    job['jid']
  else
    msg = "Failed to enqueue #{job} to run at #{time}."
    logger.fatal(msg)
    raise msg
  end
end

.logger ⇒ Object 



102
103
104
105
106
107
108
 
# File 'lib/when-do.rb', line 102

def self.logger
  @logger ||= if config[:log_path]
    Logger.new(config[:log_path], 100, 10_240_000)
  else
    Logger.new(STDOUT)
  end
end

.logger=(new_logger) ⇒ Object 



110
111
112
113
 
# File 'lib/when-do.rb', line 110

def self.logger=(new_logger)
  logger.info("Changing logger to #{new_logger.inspect}")
  @logger = new_logger
end

.redis ⇒ Object 



80
81
82
83
84
85
86
 
# File 'lib/when-do.rb', line 80

def self.redis
  @redis ||= if config[:redis_config_path]
    Redis.new(YAML.load(File.read(config[:redis_config_path])))
  else
    Redis.new
  end
end

.redis=(redis) ⇒ Object 



88
89
90
91
 
# File 'lib/when-do.rb', line 88

def self.redis=(redis)
  logger.info("Resetting redis to #{redis.inspect}")
  @redis = redis
end

.schedule(name, cron, klass, args: [], worker_args: {}) ⇒ Object

Raises:



19
20
21
22
23
24
25
 
# File 'lib/when-do.rb', line 19

def self.schedule(name, cron, klass, args: [], worker_args: {})
  raise InvalidCron, "\"#{cron}\" is invalid" unless valid_cron?(cron)
  validate_args(args)
  schedule = worker_args.merge('class' => klass.to_s, 'cron' => cron, 'args' => args)
  redis.hset(schedule_key, name.to_s, schedule.to_json)
  logger.info("Scheduled '#{name}' => #{schedule}.")
end

.schedule_key ⇒ Object 



115
116
117
 
# File 'lib/when-do.rb', line 115

def self.schedule_key
  config[:schedule_key] || 'when:schedules'
end

.schedules ⇒ Object 



49
50
51
52
 
# File 'lib/when-do.rb', line 49

def self.schedules
  schedules = redis.hgetall(schedule_key)
  schedules.each { |k, v| schedules[k] = JSON.parse(v) }
end

.unschedule(name) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/when-do.rb', line 31

def self.unschedule(name)
  json_sched = redis.hget(schedule_key, name.to_s)
  schedule = JSON.parse(json_sched) if json_sched
  if redis.hdel(schedule_key, name.to_s) > 0
    logger.info("Unscheduled '#{name}' => #{schedule}.")
    true
  else
    logger.warn("Could not unschedule '#{name}'. No schedule by that name was found.")
    false
  end
end

.unschedule_all ⇒ Object 



43
44
45
46
47
 
# File 'lib/when-do.rb', line 43

def self.unschedule_all
  count = redis.del(schedule_key)
  logger.info("Cleared #{count} schedules.")
  count
end

.valid_cron?(cron) ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
 
# File 'lib/when-do.rb', line 27

def self.valid_cron?(cron)
  When::Cron.valid?(cron)
end

.worker_queue_key ⇒ Object 



123
124
125
 
# File 'lib/when-do.rb', line 123

def self.worker_queue_key
  config[:worker_queue_key] || 'when:queue:default'
end