Class: Clockwork::Manager

Inherits:
Object
  • Object
show all
Defined in:
lib/clockwork/manager.rb

Defined Under Namespace

Classes: NoHandlerDefined

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initializeManager

Returns a new instance of Manager.



7
8
9
10
11
12
# File 'lib/clockwork/manager.rb', line 7

def initialize
  @events = []
  @callbacks = {}
  @config = default_configuration
  @handler = nil
end

Instance Attribute Details

#configObject (readonly)

Returns the value of attribute config.



5
6
7
# File 'lib/clockwork/manager.rb', line 5

def config
  @config
end

Instance Method Details

#configure {|config| ... } ⇒ Object

Yields:



18
19
20
# File 'lib/clockwork/manager.rb', line 18

def configure
  yield(config)
end

#default_configurationObject



22
23
24
# File 'lib/clockwork/manager.rb', line 22

def default_configuration
  { :sleep_timeout => 1, :logger => Logger.new(STDOUT), :thread => false, :max_threads => 10 }
end

#error_handler(&block) ⇒ Object



35
36
37
# File 'lib/clockwork/manager.rb', line 35

def error_handler(&block)
  @error_handler = block
end

#every(period, job, options = {}, &block) ⇒ Object



48
49
50
51
52
53
54
# File 'lib/clockwork/manager.rb', line 48

def every(period, job, options={}, &block)
  if options[:at].respond_to?(:each)
    every_with_multiple_times(period, job, options, &block)
  else
    register(period, job, block, options)
  end
end

#fire_callbacks(event, *args) ⇒ Object



56
57
58
# File 'lib/clockwork/manager.rb', line 56

def fire_callbacks(event, *args)
  @callbacks[event].nil? || @callbacks[event].all? { |h| h.call(*args) }
end

#get_error_handlerObject



39
40
41
# File 'lib/clockwork/manager.rb', line 39

def get_error_handler
  @error_handler
end

#get_handlerObject

Raises:



30
31
32
33
# File 'lib/clockwork/manager.rb', line 30

def get_handler
  raise NoHandlerDefined unless (defined?(@handler) and @handler)
  @handler
end

#handler(&block) ⇒ Object



26
27
28
# File 'lib/clockwork/manager.rb', line 26

def handler(&block)
  @handler = block
end

#on(event, options = {}, &block) ⇒ Object



43
44
45
46
# File 'lib/clockwork/manager.rb', line 43

def on(event, options={}, &block)
  raise "Unsupported callback #{event}" unless [:before_tick, :after_tick, :before_run, :after_run].include?(event.to_sym)
  (@callbacks[event.to_sym]||=[]) << block
end

#runObject



60
61
62
63
64
65
66
# File 'lib/clockwork/manager.rb', line 60

def run
  log "Starting clock for #{@events.size} events: [ " + @events.map { |e| e.to_s }.join(' ') + " ]"
  loop do
    tick
    sleep(config[:sleep_timeout])
  end
end

#thread_available?Boolean

Returns:

  • (Boolean)


14
15
16
# File 'lib/clockwork/manager.rb', line 14

def thread_available?
  Thread.list.count < config[:max_threads]
end

#tick(t = Time.now) ⇒ Object



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
# File 'lib/clockwork/manager.rb', line 68

def tick(t=Time.now)
  if (fire_callbacks(:before_tick))
    to_run = @events.select do |event|
      event.time?(t)
    end

    to_run.each do |event|
      if (fire_callbacks(:before_run, event, t))
        log "Triggering '#{event}'"
        event.run(t)
        fire_callbacks(:after_run, event, t)
      end
    end
  end

  fire_callbacks(:after_tick)
  to_run
end