def exit_sequence(name, id, queue_task):
sequence = sequences[name]
section = sequence.popleft()
assert section['id'] == id
if sequence:
queue_task(0, sequence[0]['deferred'].callback, sequence[0]['id'])
else:
sequences.pop(name)
def wait_for_input():
try:
prompt = ">>> "
if source:
prompt = "... "
s = ic.raw_input(prompt)
except EOFError:
eventloop.queue_task(0, eventloop.halt)
return
eventloop.queue_task(0, cb, s)
def wait_for_input():
try:
prompt = ">>> "
if source:
prompt = "... "
s = ic.raw_input(prompt)
except EOFError:
eventloop.queue_task(0, eventloop.halt)
return
eventloop.queue_task(0, cb, s)
def test_read_some_delay(self):
data = 'ok'
self.conn.timeout = 0.2
def populate():
self.buffer = data
self.stack_conn.read_cb(None)
eventloop.queue_task(0.1, populate)
r = yield self.conn.read_some()
self.assertEqual(r, data)
self.assertEqual(self.stack_conn.resume_called, 1)
yield sleep(0.2) # ensure timeout has expired
def test_read_delay(self):
data = 'ok'
self.buffer = 'o'
self.conn.timeout = 0.2
def populate():
self.buffer += 'k'
self.stack_conn.read_cb(None)
eventloop.queue_task(0.1, populate)
r = yield self.conn.read(2)
assert r == data
assert self.stack_conn.resume_called == 1
yield sleep(0.2) # ensure timeout has expired
def test_read_some_delay(self):
data = 'ok'
self.conn.timeout = 0.2
def populate():
self.buffer = data
self.stack_conn.read_cb(None)
eventloop.queue_task(0.1, populate)
r = yield self.conn.read_some()
self.assertEqual(r, data)
self.assertEqual(self.stack_conn.resume_called, 1)
yield sleep(0.2) # ensure timeout has expired
def send(self, value):
if self._recv_cbs:
# if there are receivers waiting, send to the first one
rcb = self._recv_cbs.popleft()
queue_task(0, rcb, value)
elif len(self._msgs) < self.bufsize:
# if there's available buffer, use that
self._msgs.append(value)
else:
# otherwise, wait for a receiver
cb = Callback()
self._send_cbs.append(cb)
rcb = yield cb
queue_task(0, rcb, value)
def send(self, value):
if self._recv_cbs:
# if there are receivers waiting, send to the first one
rcb = self._recv_cbs.popleft()
queue_task(0, rcb, value)
elif len(self._msgs) < self.bufsize:
# if there's available buffer, use that
self._msgs.append(value)
else:
# otherwise, wait for a receiver
cb = Callback()
self._send_cbs.append(cb)
rcb = yield cb
queue_task(0, rcb, value)
def test_read_delay(self):
data = 'ok'
self.buffer = 'o'
self.conn.timeout = 0.2
def populate():
self.buffer += 'k'
self.stack_conn.read_cb(None)
eventloop.queue_task(0.1, populate)
r = yield self.conn.read(2)
assert r == data
assert self.stack_conn.resume_called == 1
yield sleep(0.2) # ensure timeout has expired
def fire(self, value):
if not self._wait_df:
if len(self._msgs) >= self.bufsize:
if not self._fire_df:
self._fire_df = Deferred()
yield self._fire_df
if not self._wait_df:
assert (len(self._msgs) < self.bufsize)
self._msgs.append(value)
return
assert(len(self._msgs) == 0)
df = self._wait_df
self._wait_df = None
queue_task(0, df.callback, value)
def _queue_timeout(self, cb):
if self.timeout is not None:
if self._current_timeout:
self._current_timeout.cancel()
self._current_timeout = evlp.queue_task(self.timeout,
self._time_out, cb,
self.timeout)
def _queue_timeout(self, cb):
if self.timeout is not None:
if self._current_timeout:
self._current_timeout.cancel()
self._current_timeout = evlp.queue_task(self.timeout,
self._time_out,
cb,
self.timeout)
def wait(self):
popped = False
if self._msgs:
value = self._msgs.popleft()
popped = True
if not self._wait_df:
self._wait_df = Deferred()
wait_df = self._wait_df
if self._fire_df:
df = self._fire_df
self._fire_df = None
queue_task(0, df.callback, None)
if not popped:
value = yield wait_df
yield value
return fifth()
@_o
def third():
yield fourth()
def second():
return third()
@_o
def first():
yield second()
@_o
def first_evlp():
try:
yield sleep(1)
yield req()
yield launch(second)
finally:
eventloop.halt()
launch(first)
eventloop.queue_task(0, first_evlp)
eventloop.run()
import sys
import monocle
from monocle import _o
monocle.init(sys.argv[1])
from monocle.stack import eventloop
from monocle.util import sleep
@_o
def foo(x, z=1):
yield sleep(1)
print x
def bar(x, z=1):
print x
@_o
def fail():
raise Exception("whoo")
yield sleep(1)
eventloop.queue_task(0, foo, x="oroutine worked")
eventloop.queue_task(0, bar, x="function worked")
eventloop.queue_task(0, fail)
eventloop.run()
def sleep(seconds):
cb = Callback()
queue_task(seconds, cb, None)
return cb
def delayed(seconds, val):
cb = Callback()
queue_task(seconds, cb, val)
return cb
def delayed(seconds, val):
cb = Callback()
queue_task(seconds, cb, val)
return cb
def sleep(seconds):
d = Deferred()
queue_task(seconds, d.callback, None)
return d
import monocle
from monocle import _o
monocle.init(sys.argv[1])
from monocle.stack import eventloop
from monocle.util import sleep
@_o
def yielding_oroutine(x, z=1):
yield sleep(1)
print x
def nonyielding_oroutine(x, z=1):
print x
@_o
def fail():
raise Exception("whoo")
yield sleep(1)
eventloop.queue_task(0, yielding_oroutine, x="oroutine worked")
eventloop.queue_task(0, nonyielding_oroutine, x="function worked")
eventloop.queue_task(0, fail)
eventloop.run()
import monocle
from monocle import _o
monocle.init(sys.argv[1])
from monocle.stack import eventloop
from monocle.util import sleep
@_o
def yielding_oroutine(x, z=1):
yield sleep(1)
print(x)
def nonyielding_oroutine(x, z=1):
print(x)
@_o
def fail():
raise Exception("whoo")
yield sleep(1)
eventloop.queue_task(0, yielding_oroutine, x="oroutine worked")
eventloop.queue_task(0, nonyielding_oroutine, x="function worked")
eventloop.queue_task(0, fail)
eventloop.run()
def proc_wrapper():
eventloop.queue_task(0, target, *args, **kwargs)
eventloop.run()
def sleep(seconds):
cb = Callback()
queue_task(seconds, cb, None)
return cb
import sys
import monocle
from monocle import _o
monocle.init(sys.argv[1])
from monocle.stack import eventloop
from monocle.util import sleep
@_o
def foo(x, z=1):
yield sleep(1)
print x
def bar(x, z=1):
print x
@_o
def fail():
raise Exception("whoo")
yield sleep(1)
eventloop.queue_task(0, foo, x="oroutine worked")
eventloop.queue_task(0, bar, x="function worked")
eventloop.queue_task(0, fail)
eventloop.run()
def proc_wrapper():
eventloop.queue_task(0, target, *args, **kwargs)
eventloop.run()
die()
def fourth():
return fifth()
@_o
def third():
yield fourth()
def second():
return third()
@_o
def first():
yield second()
@_o
def first_evlp():
try:
yield sleep(1)
yield req()
yield launch(second)
finally:
eventloop.halt()
launch(first)
eventloop.queue_task(0, first_evlp)
eventloop.run()