Module: EventMachine::Synchrony

Defined in:
lib/em-synchrony.rb,
lib/em-synchrony/amqp.rb,
lib/em-synchrony/thread.rb,
lib/em-synchrony/em-multi.rb,
lib/em-synchrony/iterator.rb,
lib/em-synchrony/keyboard.rb,
lib/em-synchrony/tcpsocket.rb,
lib/em-synchrony/fiber_iterator.rb,
lib/em-synchrony/connection_pool.rb

Defined Under Namespace

Modules: AMQP, Thread Classes: ConnectionPool, FiberIterator, Iterator, Keyboard, KeyboardHandler, Multi, TCPSocket

Class Method Summary collapse

Class Method Details

.add_periodic_timer(interval, &blk) ⇒ Object

Fiber-aware EventMachine timer: wraps the passed in block within a new fiber (new fiber on every invocation) to allow you to continue using synchrony methods


105
106
107
108
109
# File 'lib/em-synchrony.rb', line 105

def self.add_periodic_timer(interval, &blk)
  EM.add_periodic_timer(interval) do
    Fiber.new { blk.call }.resume
  end
end

.add_timer(interval, &blk) ⇒ Object

Fiber-aware EventMachine timer: wraps the passed in block within a new fiber context such that you can continue using synchrony methods


95
96
97
98
99
# File 'lib/em-synchrony.rb', line 95

def self.add_timer(interval, &blk)
  EM::Timer.new(interval) do
    Fiber.new { blk.call }.resume
  end
end

.defer(op = nil, &blk) ⇒ Object

Fiber-aware EM.defer


119
120
121
122
123
# File 'lib/em-synchrony.rb', line 119

def self.defer op = nil, &blk
  fiber = Fiber.current
  EM.defer(op || blk, lambda{ |result| fiber.resume(result) })
  Fiber.yield
end

.getsObject

Routes to EM::Synchrony::Keyboard


135
136
137
# File 'lib/em-synchrony.rb', line 135

def self.gets
  EventMachine::Synchrony::Keyboard.new.gets
end

.next_tick(&blk) ⇒ Object

Fiber-aware EM.next_tick convenience function


113
114
115
# File 'lib/em-synchrony.rb', line 113

def self.next_tick(&blk)
  EM.next_tick { Fiber.new { blk.call }.resume }
end

.sleep(secs) ⇒ Object

Fiber-aware sleep function using an EM timer

Execution is stopped for specified amount of seconds and then automatically resumed (just like regular sleep) except without locking the reactor thread


85
86
87
88
89
# File 'lib/em-synchrony.rb', line 85

def self.sleep(secs)
  fiber = Fiber.current
  EM::Timer.new(secs) { fiber.resume }
  Fiber.yield
end

.sync(df) ⇒ Object

sync is a close relative to inlineCallbacks from Twisted (Python)

Synchrony.sync allows you to write sequential code while using asynchronous or callback-based methods under the hood. Example:

result = EM::Synchrony.sync EventMachine::HttpRequest.new(URL).get p result.response

As long as the asynchronous function returns a Deferrable object, which has a “callback” and an “errback”, the sync methond will automatically yield and automatically resume your code (via Fibers) when the call either succeeds or fails. You do not need to patch or modify the Deferrable object, simply pass it to EM::Synchrony.sync


62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
# File 'lib/em-synchrony.rb', line 62

def self.sync(df)
  f = Fiber.current
  xback = proc do |*args|
    if f == Fiber.current
      return args.size == 1 ? args.first : args
    else
      f.resume(*args)
    end
  end

  df.callback(&xback)
  df.errback(&xback)

  Fiber.yield
end

.system(cmd, *args) ⇒ Object

Fiber-aware EM.system


127
128
129
130
131
# File 'lib/em-synchrony.rb', line 127

def self.system cmd, *args
  fiber = Fiber.current
  EM.system(cmd, *args){ |out, status| fiber.resume( [out, status] ) }
  Fiber.yield
end