Class: Rack::Timeout::Scheduler

Inherits:
Object
  • Object
show all
Includes:
MonotonicTime
Defined in:
lib/rack/timeout/support/scheduler.rb

Overview

Runs code at a later time

Basic usage:

Scheduler.run_in(5) { do_stuff }  # <- calls do_stuff 5 seconds from now

Scheduled events run in sequence in a separate thread, the main thread continues on. That means you may need to #join the scheduler if the main thread is only waiting on scheduled events to run.

Scheduler.join

Basic usage is through a singleton instance, its methods are available as class methods, as shown above. One could also instantiate separate instances which would get you separate run threads, but generally there’s no point in it.

Defined Under Namespace

Classes: RepeatEvent, RunEvent, Timeout

Constant Summary collapse

MAX_IDLE_SECS =

how long the runner thread is allowed to live doing nothing

30

Class Method Summary collapse

Instance Method Summary collapse

Methods included from MonotonicTime

#fsecs_java, #fsecs_mono

Constructor Details

#initialize ⇒ Scheduler

Returns a new instance of Scheduler.



57
58
59
60
61
62
 
# File 'lib/rack/timeout/support/scheduler.rb', line 57

def initialize
  @runner    = nil
  @events    = []         # array of `RunEvent`s
  @mx_events = Mutex.new  # mutex to change said array
  @mx_runner = Mutex.new  # mutex for creating a runner thread
end

Class Method Details

.singleton ⇒ Object

accessor to the singleton instance



145
146
147
 
# File 'lib/rack/timeout/support/scheduler.rb', line 145

def self.singleton
  @singleton ||= new
end

Instance Method Details

#delay(event, secs) ⇒ Object

reschedules an event by the given number of seconds. can be negative to run sooner. returns nil and does nothing if the event is not already in the queue (might’ve run already), otherwise updates the event time in-place; returns the updated event.



122
123
124
125
126
127
128
129
 
# File 'lib/rack/timeout/support/scheduler.rb', line 122

def delay(event, secs)
  @mx_events.synchronize {
    return unless @events.include? event
    event.monotime += secs
    runner.run
    return event
  }
end

#join ⇒ Object

waits on the runner thread to finish



108
109
110
111
 
# File 'lib/rack/timeout/support/scheduler.rb', line 108

def join
  @joined = true
  runner.join
end

#run_every(seconds, &block) ⇒ Object

schedules a block to run every x seconds; returns the created event object



137
138
139
 
# File 'lib/rack/timeout/support/scheduler.rb', line 137

def run_every(seconds, &block)
  schedule RepeatEvent.new(fsecs, block, seconds)
end

#run_in(secs, &block) ⇒ Object

schedules a block to run in the given number of seconds; returns the created event object



132
133
134
 
# File 'lib/rack/timeout/support/scheduler.rb', line 132

def run_in(secs, &block)
  schedule RunEvent.new(fsecs + secs, block)
end

#schedule(event) ⇒ Object

adds a RunEvent struct to the run schedule



114
115
116
117
118
 
# File 'lib/rack/timeout/support/scheduler.rb', line 114

def schedule(event)
  @mx_events.synchronize { @events << event }
  runner.run  # wakes up the runner thread so it can recalculate sleep length taking this new event into consideration
  return event
end