Module: When

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

Defined Under Namespace

Classes: CLI, Do

Constant Summary collapse

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

Class Method Summary collapse

Class Method Details

.config ⇒ Object 



78
79
80
 
# File 'lib/when-do.rb', line 78

def self.config
  @config ||= DEFAULT_CONFIG
end

.config=(new_config) ⇒ Object 



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

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

.delayed_queue_key ⇒ Object 



104
105
106
 
# File 'lib/when-do.rb', line 104

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

.enqueue(klass, *args) ⇒ Object 



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

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

.enqueue_at(time, klass, *args) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/when-do.rb', line 42

def self.enqueue_at(time, klass, *args)
  job = { '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 



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

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 



95
96
97
98
 
# File 'lib/when-do.rb', line 95

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

.redis ⇒ Object 



65
66
67
68
69
70
71
 
# File 'lib/when-do.rb', line 65

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 



73
74
75
76
 
# File 'lib/when-do.rb', line 73

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

.schedule(name, cron, klass, *args) ⇒ Object 



13
14
15
16
17
 
# File 'lib/when-do.rb', line 13

def self.schedule(name, cron, klass, *args)
  schedule = {'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 



100
101
102
 
# File 'lib/when-do.rb', line 100

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

.schedules ⇒ Object 



37
38
39
40
 
# File 'lib/when-do.rb', line 37

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

.unschedule(name) ⇒ Object 



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

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 



31
32
33
34
35
 
# File 'lib/when-do.rb', line 31

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

.worker_queue_key ⇒ Object 



108
109
110
 
# File 'lib/when-do.rb', line 108

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