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 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 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)