def run(row, col, size, wrap, speed, steps=None, state=None):
if state is None:
state = random.choice((True, False, False, False))
neighbors = get_neighbors(row, col, size, wrap)
neighbors = {n: i for i, n in enumerate(neighbors)}
n = len(neighbors)
# Throttle at 100 connections / second on average
yield from tulip.sleep(size * size / 100 * random.random())
ws = yield from websockets.connect('ws://localhost:8000/worker/')
# Wait until all clients are connected.
msg = yield from ws.recv()
if msg != 'sub':
raise Exception("Unexpected message: {}".format(msg))
# Subscribe to updates sent by neighbors.
for neighbor in neighbors:
ws.send('{} {}'.format(*neighbor))
ws.send('sub')
# Wait until all clients are subscribed.
msg = yield from ws.recv()
if msg != 'run':
raise Exception("Unexpected message: {}".format(msg))
ws.send('{} {} {} {}'.format(0, row, col, int(state)))
# This is the step for which we last sent our state, and for which we're
# collecting the states of our neighbors.
step = 0
# Once we know all our neighbors' states at step N - 1, we compute and
# send our state at step N. At this point, our neighbors can send their
# states at steps N and N + 1, but not N + 2, since that requires our
# state at step N + 1. We only need to keep track of two sets of states.
states = [[None] * n, [None] * n]
# Gather state updates from neighbors and send our own state updates.
while (steps is None or step < steps):
msg = yield from ws.recv()
if msg is None:
break
_step, _row, _col, _state = (int(x) for x in msg.split())
target = _step % 2
states[target][neighbors[(_row, _col)]] = bool(_state)
# Compute next state
if None not in states[target]:
assert _step == step
step += 1
alive = states[target].count(True)
state = alive == 3 or (state and alive == 2)
states[target] = [None] * n
ws.send('{} {} {} {}'.format(step, row, col, int(state)))
# Throttle, speed is a number of steps per second
yield from tulip.sleep(1 / speed)
yield from ws.close()
def run(row, col, size, wrap, speed, steps=None, state=None):
if state is None:
state = random.choice((True, False, False, False))
neighbors = get_neighbors(row, col, size, wrap)
neighbors = {n: i for i, n in enumerate(neighbors)}
n = len(neighbors)
# Throttle at 100 connections / second on average
yield from tulip.sleep(size * size / 100 * random.random())
ws = yield from websockets.connect('ws://localhost:8000/worker/')
# Wait until all clients are connected.
msg = yield from ws.recv()
if msg != 'sub':
raise Exception("Unexpected message: {}".format(msg))
# Subscribe to updates sent by neighbors.
for neighbor in neighbors:
ws.send('{} {}'.format(*neighbor))
ws.send('sub')
# Wait until all clients are subscribed.
msg = yield from ws.recv()
if msg != 'run':
raise Exception("Unexpected message: {}".format(msg))
ws.send('{} {} {} {}'.format(0, row, col, int(state)))
# This is the step for which we last sent our state, and for which we're
# collecting the states of our neighbors.
step = 0
# Once we know all our neighbors' states at step N - 1, we compute and
# send our state at step N. At this point, our neighbors can send their
# states at steps N and N + 1, but not N + 2, since that requires our
# state at step N + 1. We only need to keep track of two sets of states.
states = [[None] * n, [None] * n]
# Gather state updates from neighbors and send our own state updates.
while (steps is None or step < steps):
msg = yield from ws.recv()
if msg is None:
break
_step, _row, _col, _state = (int(x) for x in msg.split())
target = _step % 2
states[target][neighbors[(_row, _col)]] = bool(_state)
# Compute next state
if None not in states[target]:
assert _step == step
step += 1
alive = states[target].count(True)
state = alive == 3 or (state and alive == 2)
states[target] = [None] * n
ws.send('{} {} {} {}'.format(step, row, col, int(state)))
# Throttle, speed is a number of steps per second
yield from tulip.sleep(1 / speed)
yield from ws.close()
def run(self):
self.addurls([(self.rooturl, '')]) # Set initial work.
yield from tulip.sleep(1)
while self.busy:
yield from tulip.sleep(1)
self.session.close()
self.loop.stop()
def scanport(port):
ippat = "10.1.10.%d"
loop = tulip.get_event_loop()
loop.add_signal_handler(signal.SIGINT, loop.stop)
futs = []
for x in range(1, 255):
host = ippat % x
print("trying", host, port, end="\r", flush=True)
fut = tulip.Task(loop.create_connection(Scanner, host, port), timeout=1)
futs.append(fut)
loop.run_until_complete(tulip.sleep(0.001))
print()
for fut in futs:
try:
loop.run_until_complete(fut)
except tulip.CancelledError:
pass
except os.error as exc:
if exc.errno == 24:
print()
print(exc)
except Exception as exc:
print()
print(exc)
print()
loop.call_later(1, loop.stop)
loop.run_forever()
def _run(self):
def factory():
return tulip.http.WSGIServerHttpProtocol(self.wsgi,
readpayload=True)
# insert sockets to event_loop
for sock in self.sockets:
self.ev_loop.start_serving(factory, sock=sock)
# If our parent changed then we shut down.
pid = os.getpid()
try:
while self.alive:
self.notify()
if pid == os.getpid() and self.ppid != os.getppid():
self.log.info("Parent changed, shutting down: %s", self)
break
yield from tulip.sleep(1.0)
except KeyboardInterrupt:
pass
tulip.get_event_loop().stop()
tulip.get_event_loop().close()
def handle_request(self, message, payload):
if properties.get('close', False):
return
if properties.get('noresponse', False):
yield from tulip.sleep(99999)
if router is not None:
body = bytearray()
chunk = yield from payload.read()
while chunk:
body.extend(chunk)
chunk = yield from payload.read()
rob = router(self, properties, self.transport, message,
bytes(body))
rob.dispatch()
else:
response = tulip.http.Response(self.transport, 200,
message.version)
text = b'Test message'
response.add_header('Content-type', 'text/plain')
response.add_header('Content-length', str(len(text)))
response.send_headers()
response.write(text)
response.write_eof()
def _run(self):
def factory():
return tulip.http.WSGIServerHttpProtocol(
self.wsgi, readpayload=True)
# insert sockets to event_loop
for sock in self.sockets:
self.ev_loop.start_serving(factory, sock=sock)
# If our parent changed then we shut down.
pid = os.getpid()
try:
while self.alive:
self.notify()
if pid == os.getpid() and self.ppid != os.getppid():
self.log.info("Parent changed, shutting down: %s", self)
break
yield from tulip.sleep(1.0)
except KeyboardInterrupt:
pass
tulip.get_event_loop().stop()
tulip.get_event_loop().close()
def handle_request(self, message, payload):
if properties.get('close', False):
return
if properties.get('noresponse', False):
yield from tulip.sleep(99999)
if router is not None:
body = bytearray()
chunk = yield from payload.read()
while chunk:
body.extend(chunk)
chunk = yield from payload.read()
rob = router(
self, properties,
self.transport, message, bytes(body))
rob.dispatch()
else:
response = tulip.http.Response(
self.transport, 200, message.version)
text = b'Test message'
response.add_header('Content-type', 'text/plain')
response.add_header('Content-length', str(len(text)))
response.send_headers()
response.write(text)
response.write_eof()
def scanport(port):
ippat = '10.1.10.%d'
loop = tulip.get_event_loop()
loop.add_signal_handler(signal.SIGINT, loop.stop)
futs = []
for x in range(1, 255):
host = ippat % x
print('trying', host, port, end='\r', flush=True)
fut = tulip.Task(loop.create_connection(Scanner, host, port),
timeout=1)
futs.append(fut)
loop.run_until_complete(tulip.sleep(0.001))
print()
for fut in futs:
try:
loop.run_until_complete(fut)
except tulip.CancelledError:
pass
except os.error as exc:
if exc.errno == 24:
print()
print(exc)
except Exception as exc:
print()
print(exc)
print()
loop.call_later(1, loop.stop)
loop.run_forever()
def main():
url = len(sys.argv) > 1 and sys.argv[1] or 'http://example.com/'
loop = tulip.get_event_loop()
lock = tulip.locks.Lock()
loop.call_soon(download, 'http://example.com', lock)
loop.call_later(4, download, 'http://google.com', lock)
loop.call_later(8, download, 'http://some_lame_address_1111.com', lock)
loop.run_until_complete(tulip.sleep(20))
def main():
url = len(sys.argv) > 1 and sys.argv[1] or 'http://example.com/'
loop = tulip.get_event_loop()
lock = tulip.locks.Lock()
loop.call_soon(download, 'http://example.com', lock)
loop.call_later(4, download, 'http://google.com', lock)
loop.call_later(8, download, 'http://some_lame_address_1111.com', lock)
loop.run_until_complete(tulip.sleep(20))
def watch_input_file():
mtime = op.getmtime(FILENAME)
while True:
new_mtime = op.getmtime(FILENAME)
if new_mtime > mtime:
render_slides()
mtime = new_mtime
print('Updated page at {}'.format(time.ctime()))
yield from tulip.sleep(.5)
def start(client, data):
task1 = tulip.Task(foo(client))
task2 = tulip.Task(bar(client))
while True:
if task1.done() and task2.done():
client.log(task1.result())
client.log(task2.result())
break
else:
yield from tulip.sleep(1)
def start(client, data):
task1 = tulip.Task(foo(client))
task2 = tulip.Task(bar(client))
while True:
if task1.done() and task2.done():
client.log(task1.result())
client.log(task2.result())
break
else:
yield from tulip.sleep(1)
def watch_input_file():
mtime = op.getmtime(FILENAME)
while True:
new_mtime = op.getmtime(FILENAME)
if new_mtime > mtime:
render_slides()
mtime = new_mtime
print('Updated page at {}'.format(time.ctime()))
yield from tulip.sleep(.5)
def heartbeat(self, writer):
while True:
yield from tulip.sleep(15)
if (time.monotonic() - self.ping) < 30:
writer.ping()
else:
print('Restart unresponsive worker process: {}'.format(
self.pid))
self.kill()
self.start()
return
def heartbeat(self, writer):
while True:
yield from tulip.sleep(15)
if (time.monotonic() - self.ping) < 30:
writer.ping()
else:
print('Restart unresponsive worker process: {}'.format(
self.pid))
self.kill()
self.start()
return
def test_echo(self):
# Distribute the connections a bit
yield from tulip.sleep(2 * self.DELAY * random.random())
ws = yield from websockets.connect(self.ECHO_URL)
self.count += 1
if self.count % (self.CLIENTS * 3 // self.DELAY) == 0:
print("> {:5} connections".format(self.count))
if self.count == self.CLIENTS:
print()
print("{} clients are connected!".format(self.count))
print()
messages = []
messages.append((yield from ws.recv()))
yield from tulip.sleep(self.DELAY)
ws.send('Spam?')
messages.append((yield from ws.recv()))
yield from tulip.sleep(self.DELAY)
ws.send('Eggs!')
messages.append((yield from ws.recv()))
yield from tulip.sleep(self.DELAY)
ws.send('Python.')
messages.append((yield from ws.recv()))
messages.append((yield from ws.recv()))
assert messages == [
"Hello!",
"1. Spam?",
"2. Eggs!",
"3. Python.",
"Goodbye!",
]
yield from ws.close()
self.count -= 1
if self.count % (self.CLIENTS * 3 // self.DELAY) == 0:
print("< {:5} connections".format(self.count))
def download(url, retries=3, sleep=5, loop=None):
loop = loop or tulip.get_event_loop()
print('DOWNLOADING', url)
data = None
for i in range(retries):
try:
data = yield from download_single(loop, url)
except Exception:
print("FAILED TO DOWNLOAD", url, "RETRYING.")
yield from tulip.sleep(sleep)
else:
break
else:
print("FAILED TO DOWNLOAD", url)
return
return data
def nest(depth, dt):
if depth > 0:
yield from nest(depth-1, dt/2)
yield from nest(depth-1, dt/2)
else:
yield from tulip.sleep(dt)
def make_widget():
yield from tulip.sleep(random.random())
return _make_widget()
def nest(depth, dt):
if depth > 0:
yield from nest(depth - 1, dt / 2)
yield from nest(depth - 1, dt / 2)
else:
yield from tulip.sleep(dt)
def test_recv_when_recv_already_waiting(self):
tulip.Task(self.protocol.recv())
self.loop.run_until_complete(tulip.sleep(MS)) # make task start
self.loop.call_later(MS, self.fast_connection_failure)
with self.assertRaises(RuntimeError):
self.loop.run_until_complete(self.protocol.recv())
def run(self):
while True:
for task in self.tasks:
yield from task()
yield from tulip.sleep(1)
def flat(depth, dt):
n = 2**depth
dt_n = dt / n
for _ in range(n):
yield from tulip.sleep(dt_n)
def auto_update(self):
while True:
yield from self.update_quote()
yield from tulip.sleep(self.interval)
def watch(self):
while True:
for order_ in reversed(self.redis.lrange('orders', 0, -1)):
order = pickle.loads(order_)
print('order', order)
if order['type'] == 'buy':
self.redis.lrem(name='orders', count=0, value=order_)
if order['take']:
assert order['price'] < order['take']
if order['stop']:
assert order['price'] < order['stop']
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
if order['stop']:
yield from self.sell_limit(currency=order['currency'],
amount=order['amount'],
price=order['stop'],
stop=0,
take=0)
if order['take']:
yield from self.sell_stop(currency=order['currency'],
amount=order['amount'],
price=order['take'],
stop=0,
take=0)
elif order['type'] == 'buy_stop':
if order['take']:
assert order['price'] < order['take']
if order['stop']:
assert order['price'] > order['stop']
trigger = yield from self.check_buy_stop(order=order)
if trigger:
self.redis.lrem(name='orders', count=0, value=order_)
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
elif order['type'] == 'buy_limit':
if order['take']:
assert order['price'] < order['take']
if order['stop']:
assert order['price'] > order['stop']
trigger = yield from self.check_buy_limit(order=order)
if trigger:
self.redis.lrem(name='orders', count=0, value=order_)
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
elif order['type'] == 'sell':
self.redis.lrem(name='orders', count=0, value=order_)
if order['take']:
assert order['price'] > order['take']
if order['stop']:
assert order['price'] < order['stop']
yield from self.sell_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
if order['stop']:
yield from self.buy_limit(currency=order['currency'],
amount=order['amount'],
price=order['take'],
stop=0,
take=0)
if order['take']:
yield from self.buy_stop(currency=order['currency'],
amount=order['amount'],
price=order['stop'],
stop=0,
take=0)
elif order['type'] == 'sell_stop':
if order['take']:
assert order['price'] > order['take']
if order['stop']:
assert order['price'] < order['stop']
trigger = yield from self.check_sell_stop(order=order)
if trigger:
self.redis.lrem(name='orders', count=0, value=order_)
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
elif order['type'] == 'sell_limit':
if order['take']:
assert order['price'] > order['take']
if order['stop']:
assert order['price'] < order['stop']
trigger = yield from self.check_sell_limit(order=order)
if trigger:
self.redis.lrem(name='orders', count=0, value=order_)
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
yield from tulip.sleep(1)
def flat(depth, dt):
n = 2**depth
dt_n = dt/ n
for _ in range(n):
yield from tulip.sleep(dt_n)
def auto_update(self):
while True:
yield from self.update_quote()
yield from tulip.sleep(self.interval)
def run(self):
while True:
for task in self.tasks:
yield from task()
yield from tulip.sleep(1)
def make_widget():
yield from tulip.sleep(random.random())
return _make_widget()
def watch(self):
while True:
for order_ in reversed(self.redis.lrange('orders', 0, -1)):
order = pickle.loads(order_)
print('order', order)
if order['type'] == 'buy':
self.redis.lrem(name='orders', count=0, value=order_)
if order['take']:
assert order['price'] < order['take']
if order['stop']:
assert order['price'] < order['stop']
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
if order['stop']:
yield from self.sell_limit(currency=order['currency'],
amount=order['amount'],
price=order['stop'],
stop=0,
take=0)
if order['take']:
yield from self.sell_stop(currency=order['currency'],
amount=order['amount'],
price=order['take'],
stop=0,
take=0)
elif order['type'] == 'buy_stop':
if order['take']:
assert order['price'] < order['take']
if order['stop']:
assert order['price'] > order['stop']
trigger = yield from self.check_buy_stop(order=order)
if trigger:
self.redis.lrem(name='orders', count=0, value=order_)
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
elif order['type'] == 'buy_limit':
if order['take']:
assert order['price'] < order['take']
if order['stop']:
assert order['price'] > order['stop']
trigger = yield from self.check_buy_limit(order=order)
if trigger:
self.redis.lrem(name='orders', count=0, value=order_)
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
elif order['type'] == 'sell':
self.redis.lrem(name='orders', count=0, value=order_)
if order['take']:
assert order['price'] > order['take']
if order['stop']:
assert order['price'] < order['stop']
yield from self.sell_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
if order['stop']:
yield from self.buy_limit(currency=order['currency'],
amount=order['amount'],
price=order['take'],
stop=0,
take=0)
if order['take']:
yield from self.buy_stop(currency=order['currency'],
amount=order['amount'],
price=order['stop'],
stop=0,
take=0)
elif order['type'] == 'sell_stop':
if order['take']:
assert order['price'] > order['take']
if order['stop']:
assert order['price'] < order['stop']
trigger = yield from self.check_sell_stop(order=order)
if trigger:
self.redis.lrem(name='orders', count=0, value=order_)
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
elif order['type'] == 'sell_limit':
if order['take']:
assert order['price'] > order['take']
if order['stop']:
assert order['price'] < order['stop']
trigger = yield from self.check_sell_limit(order=order)
if trigger:
self.redis.lrem(name='orders', count=0, value=order_)
yield from self.buy_market(currency=order['currency'],
amount=order['amount'],
stop=order['stop'],
take=order['take'])
yield from tulip.sleep(1)
