def kill_current_test(self): """ Unblock save_join() call inside LuaTest.execute(), which doing necessary servers/greenlets clean up. """ # current_test_greenlet is None for PythonTest if self.current_test.current_test_greenlet: gevent.kill(self.current_test.current_test_greenlet)
def close(self): ''' Do here all close conection logic ''' for greenlet in self.greenlets: gevent.kill(greenlet) if self.user: KITTEN_SEARCH_JOBS.pop(self.user.id) CONNECTIONS_POOL.pop(self.user.id)
def cleanup(self): if self.reconnect_job is not None: gevent.kill(self.reconnect_job) self._clean_socket() self.decoder.remove_listeners_by_key(id(self)) self.decoder.destroy()
def test_gevent_kill(self): g = gevent.spawn(self.should_never_run, 0) # create but do not switch to g2 = gevent.spawn(self.should_never_run, 1) # create but do not switch to # Using gevent.kill gevent.kill(g) gevent.kill(g2) self.check(g, g2)
def keepalive_token(self, token_id): if isinstance(token_id, Token): token = token_id token_id = self.lookup_token_id(token) else: token = self.lookup_token(token_id) if not token: raise TokenException('Token not found or expired') if token.lifetime: gevent.kill(token.timer) if token.revocation_function is not None: token.timer = gevent.spawn_later( token.lifetime, token.revocation_function, self, token, token_id ) else: token.timer = gevent.spawn_later( token.lifetime, self.revoke_token, token_id )
def killall_servers(self, server, ts, crash_occured): """ kill all servers and crash detectors before stream swap """ color_log('Kill all servers ...\n', schema='info') check_list = ts.servers.values() + [server, ] # check that all servers stopped correctly for server in check_list: bad_returncode = server.process.returncode not in (None, 0, -signal.SIGKILL, -signal.SIGTERM) # if non-default server crashed but it was expected # don't kill the default server and crash detectors crash_occured = crash_occured or \ bad_returncode and not server.crash_expected for server in check_list: server.process.poll() if crash_occured: # kill all servers and crash detectors on crash if server.process.returncode is None: server.process.kill() if server.crash_detector is not None: gevent.kill(server.crash_detector) elif server.process.returncode is not None: # join crash detectors of stopped servers if server.crash_detector is not None: save_join(server.crash_detector)
def on_close(self): try: gevent.kill(self._keepalive_greenlet) except Exception: log.exception('Failed to kill keepalive greenlet') super(IVTSession, self).on_close() self._ivt.session_closed()
def do_rebalance(self): """Rebalance the group.""" pt = ['%s-%s' % (bid, n) for (bid, np) in self.partitions.items() for n in range(np)] cg = [cid for cid in self.consumer.clients.keys()] self.log.info('rebalance: pt=%r cg=%r' % (pt, cg)) pt.sort() cg.sort() n = len(pt) / len(cg) e = len(pt) % len(cg) i = cg.index(self.consumer.consumer_id) start = n * i + min(i, e) stop = start + n + (0 if (i + 1) > e else 1) partitions = pt[start:stop] self.log.info('rebalance: won %r' % (partitions,)) for to_remove in (set(self.owned) - set(partitions)): self.log.info("stop consuming %s" % (to_remove,)) # Step 1. Stop consuming the topic. greenlet = self.readers.pop(to_remove, None) if greenlet is not None: gevent.kill(greenlet) # Step 2. Remove the owner node from the group. self.framework.delete().for_path( '/consumers/%s/owners/%s/%s' % (self.consumer.group_id, self.topic_name, to_remove)) self.owned.remove(to_remove) # Step 3. We remove the offsets entry so that we re-read # it if we ever get ownership of the partition again. self.offsets.pop(to_remove, None) # Iterate through the partitions that we just won and try to # create the "owner" node in zookeeper. If we fail to create # at least one of them, make sure that False is returned so # that the process is restarted. fail = False for partition in (set(partitions) - set(self.owned)): try: self.framework.create().as_ephemeral().with_data( self.consumer.consumer_id).parents_if_needed().for_path( '/consumers/%s/owners/%s/%s' % (self.consumer.group_id, self.topic_name, partition)) except zookeeper.NodeExistsException: self.log.info('%s: failed to create ownership' % (partition,)) fail = True continue self.owned.append(partition) if partition not in self.readers: broker_id, part_id = partition.split('-') self.readers[partition] = gevent.spawn( self._reader, partition, self.consumer.brokers[broker_id], int(part_id)) return fail != True
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' # XXX: TODO IMPLEMENT ME # # get from client, send to socket # client = Client() clients.append(client) g = gevent.spawn( read_ws, ws, client ) try: while True: # block here jdata = client.get() print "Got a message!" ws.send(jdata) except Exception as e: print "WS Error %s" % e finally: clients.remove(client) gevent.kill(g) return None
def invitation(self, remote_addr, gn): print '(INVITATION) [%s] : invites [%s]' % (remote_addr, self.addr) if self.s != "Normal": return '''CALL STOP ! ''' if len(self.greenletList) > 0: self.greenletList.pop() if len(self.greenletList) > 0: for g in self.greenletList: gevent.kill(g) self.greenletList = [] temp = self.c tempSet = self.Up self.s = "Election" self.c = remote_addr self.g = gn if temp == self.addr: for k in tempSet: try: self.connections[k].invitation(remote_addr, gn) print '(INVITATION) [%s] : invites [%s].' % (remote_addr, self.servers[k]) except zerorpc.TimeoutExpired: print '(INVITATION) [%s] : [%s] timeout!' % (self.servers[k], remote_addr) continue m = self.servers.index(remote_addr) try: self.connections[m].accept(self.addr, gn) print '(INVITATION) [%s] : accepts [%s]\'s invitation.'% (self.addr, remote_addr) except zerorpc.TimeoutExpired: print '(INVITATION) [%s] : [%s] timeout!' % (self.addr, remote_addr) self.recovery() self.s = "Reorganization"
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' client = Client() clients.append(client) g = gevent.spawn( read_ws, ws, client ) try: while True: msg = client.get() if "new" in msg: ws.send(json.dumps(myWorld.world())) else: for key in msg: if "data" in key: data = msg[key] elif "entity" in key: entity = msg[key] myWorld.set(entity, data) ws.send(json.dumps(data)) #for freetest.py data format else: ws.send(json.dumps(msg)) except Exception as e:# WebSocketError as e: print "WS Error %s" % e finally: clients.remove(client) gevent.kill(g)
def initial_sync_impl(self, crispin_client): # We wrap the block in a try/finally because the change_poller greenlet # needs to be killed when this greenlet is interrupted change_poller = None try: assert crispin_client.selected_folder_name == self.folder_name remote_uids = crispin_client.all_uids() with self.syncmanager_lock: with mailsync_session_scope() as db_session: local_uids = common.all_uids(self.account_id, db_session, self.folder_id) self.remove_deleted_uids(db_session, local_uids, remote_uids) new_uids = set(remote_uids) - local_uids download_stack = UIDStack() for uid in sorted(new_uids): download_stack.put(uid, GenericUIDMetadata(self.throttled)) with mailsync_session_scope() as db_session: self.update_uid_counts( db_session, remote_uid_count=len(remote_uids), # This is the initial size of our download_queue download_uid_count=len(new_uids)) change_poller = spawn(self.poll_for_changes, download_stack) bind_context(change_poller, 'changepoller', self.account_id, self.folder_id) self.download_uids(crispin_client, download_stack) finally: if change_poller is not None: # schedule change_poller to die kill(change_poller)
def stop_task(self, task_name): for greenlet in self.active[task_name]: try: gevent.kill(greenlet) self.active[task_name] = [] except BaseException: pass
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' client = Client() clients.append(client) g = gevent.spawn( read_ws, ws, client ) print "Subscribing" #Sends the current status of the canvas client.put(json.dumps(myWorld.world())) print('F: Sending: ' + json.dumps(myWorld.world())) try: while True: # block here msg = client.get() print "Got a message! %s" %msg ws.send(msg) except Exception as e:# WebSocketError as e: print "WS Error %s" % e finally: clients.remove(client) gevent.kill(g) return None
def test_zmqserver_exc(self): import gevent from synapse.node import ZMQServer, ZMQClient, NodeException conf_srv = {'uri': 'tcp://*:5557', 'name': 'zmqsrv'} conf_cli = {'uri': 'tcp://localhost:5557', 'name': 'zmqcli'} def srv_handler(msg): raise NodeException("buggy", "exc_result") server = ZMQServer(conf_srv, srv_handler) self.assertTrue(server.socket is None) server.start() self.assertTrue(server.socket is not None) self.assertRaises(NotImplementedError, server.send, "unimplemented") serverlet = gevent.spawn(server.loop) client = ZMQClient(conf_cli) self.assertTrue(client.socket is None) client.connect() self.assertTrue(client.socket is not None) client.send("sync_message") response = client.recv() self.assertEquals(response, "exc_result") gevent.kill(serverlet) client.close() server.stop()
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' client = Client() clients.append(client) #add the new client to the world myWorld.add_set_listener(client) g = gevent.spawn( read_ws, ws, client ) print "Subscribing" try: while True: # block here msg = client.get() print msg print "Got a message!" ws.send(msg) except Exception as e:# WebSocketError as e: print "WS Error %s" % e finally: clients.remove(client) myWorld.update_listeners(clients) gevent.kill(g) return None
def test_zmqserver_sync(self): import gevent from synapse.zmq_node import ZMQServer, ZMQClient conf_srv = {'uri': 'tcp://*:5555', 'name': 'zmq_srv_sync'} conf_cli = {'uri': 'tcp://localhost:5555', 'name': 'zmq_cli_sync'} def srv_handler(msg): return "sync_response" server = ZMQServer(conf_srv, srv_handler) self.assertTrue(server.socket is None) server.start() self.assertTrue(server.socket is not None) self.assertRaises(NotImplementedError, server.send, "unimplemented") serverlet = gevent.spawn(server.loop) client = ZMQClient(conf_cli) self.assertTrue(client.socket is None) client.connect() self.assertTrue(client.socket is not None) client.send("message") response = client.recv() self.assertEquals(response, "sync_response") gevent.kill(serverlet) client.close() server.stop()
def fcgi_abort_request(self, record, request): logger.warn('Request %s abortion' % request.id) greenlet = request.greenlet if greenlet is not None: kill(request.greenlet) else: del self.requests[request.id]
def stop(self): gevent.kill(self.greenlet) try: self.proc.kill() except OSError as e: pass
def on_close(self, reason): MONGO.close() self.MQ.release() gevent.kill(self.node_greenlet) gevent.kill(self.presence_greenlet) current = self.ws.handler.active_client logging.info("Client Left: {}".format(current.address))
def on_packet(packet): if "ping" == packet["type"] and "probe" == packet["data"]: transport.send([{ "type": "pong", "data": "probe" }]) if self.check_eventlet is not None: gevent.kill(self.check_eventlet) def loop(): while True: gevent.sleep(1) check() self.check_eventlet = gevent.Greenlet.spawn(loop) elif 'upgrade' == packet["type"] and self.ready_state == self.STATE_OPEN: self.debug("got upgrade packet - upgrading") transport.remove_listener('packet', on_packet) self._clear_transport() self._set_transport(transport) self.upgraded = True self._set_ping_timeout_eventlet() gevent.kill(self.upgrade_eventlet) self.flush_nowait() else: transport.close()
def stop(self): if self._pygics_task: self._pygics_task_sw = False gevent.kill(self._pygics_task) gevent.joinall([self._pygics_task]) self._pygics_task = None return self
def run(self): self.socket.setblocking(1) env = self.base_env.copy() env.update({ 'SERVER_NAME': self.address[0], 'SERVER_PORT': str(self.address[1]) }) self.base_env = env http = core.http() http.set_gencb(self.handle_request) self.pool = Pool(self.worker_connections) self.application = self.wsgi acceptor = gevent.spawn(http.accept, self.socket.fileno()) try: while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s" % self) gevent.kill(acceptor) break gevent.sleep(0.1) self.pool.join(timeout=self.timeout) except KeyboardInterrupt: pass
def handle_stop(self, args): """ Halt a feed. We can't look the feed up from the database here because we may have already deleted it from our records, so instead we iterate through all of our green threads until something sticks. """ key, name = args for id, ct in self.crontabs.items(): feed = ct.events[0].feed if feed.name == name and feed.key.key == key.key: if self.app.debug: self.app.log('%s: %s: Unscheduling "%s". [thread %s]' % \ (key.name, feed.group.name, feed.name, id)) else: self.app.log('%s: %s: Unscheduling "%s".' % \ (key.name, feed.group.name, feed.name)) for t in self.threads: if t.name == id: gevent.kill(t) break self.threads.remove(t) del ct del self.crontabs[id] return True return False
def remove_recipe(self, recipe): """ Remove a scheduled job from the list of scheduled jobs. """ print 'Removing: {} at {}'.format(recipe, dates.now()) self._running_recipes.pop(recipe.id) gevent.kill(self._greenlets[recipe.id]) self._greenlets.pop(recipe.id)
def close(self): self.started = False if self.eloop: gevent.kill(self.eloop) if self.sock: self.sock.close() self.reqs.clear() self.connect_lock.clear()
def start_sim(self, delay, size=1): if self.SIM_RUNNING: kill(self.sim_thread) self.updates = [] Room.objects.all().update(avail=True) self.sim_thread = spawn(self.run_sim, delay=delay, size=size) self.SIM_RUNNING = True return HttpResponse('Started Simulation with delay %d' % delay)
def gevent_stop(self): """ Helper method to stop the node for gevent-based applications. """ import gevent gevent.kill(self._poller_greenlet) self.remove() self._select = select.select
def stop(self): if self.state == VirtualMachineState.STOPPED: raise RuntimeError() gevent.kill(self.console_thread) self.bhyve_process.terminate() subprocess.call('/usr/sbin/bhyvectl --destroy --vm={0}'.format(self.name)) self.set_state(VirtualMachineState.STOPPED)
def setup_darwin(self): """ Setup for headset on the OS X platform. Receives packets from headset and sends them to a Queue to be processed by the crypto greenlet. """ # Set this to True if the OS is performing the encryption of the packets _os_decryption = False # Change these values to the hex equivalent from the output of hid_enumerate. If they are incorrect. # Current values = VendorID: 8609 ProductID: 1 #hidraw = hid.device(0x31a1, 0x2001) hidraw = hid.device(0x1234,0xed02) hidraw.open(0x1234, 0xed02) self.serial_number = 'SN20120229000290' if not hidraw: hidraw = hid.device(0x21a1, 0x1234) if not hidraw: hidraw = hid.device(0xed02, 0x1234) if not hidraw: print "Device not found. Uncomment the code in setup_darwin and modify hid.device(vendor_id, product_id)" raise ValueError if self.serial_number == "": print "Serial number needs to be specified manually in __init__()." raise ValueError print "Serial number:" + self.serial_number crypto = gevent.spawn(self.setup_crypto, self.serial_number) console_updater = gevent.spawn(self.update_console) zero = 0 while self.running: try: # Doesn't seem to matter how big we make the buffer 32 returned every time, 33 for other platforms data = hidraw.read(34,10) #data = [48]*32 if len(data) == 32: # Most of the time the 0 is truncated? That's ok we'll add it... data = [zero] + data if data != "": if _os_decryption: self.packets.put_nowait(EmotivPacket(data)) else: #Queue it! print ('Queuing package:'+len(data)) tasks.put_nowait(''.join(map(chr, data[1:]))) self.packets_received += 1 print ('Waiting...') gevent.sleep(0.01) else: # No new data from the device; yield # We cannot sleep(0) here because that would go 100% CPU if both queues are empty. gevent.sleep(DEVICE_POLL_INTERVAL) except KeyboardInterrupt: self.running = False hidraw.close() gevent.kill(crypto, KeyboardInterrupt) gevent.kill(console_updater, KeyboardInterrupt)
def subscribe_socket(ws): client = Client() clients.append(client) g = gevent.spawn(read_ws, ws, client) try: while True: # block here msg = client.get() ws.send(msg) except Exception as e: # WebSocketError as e: print "WS Error %s" % e finally: clients.remove(client) gevent.kill(g)
def handle(self, r): input = r.input_buffer output = r.output_buffer assert r.input_buffer is input assert r.output_buffer is output assert input._obj assert output._obj r.detach() assert not input._obj assert not output._obj assert input.read() == '' assert output.read() == '' self.handled = True gevent.kill(self.current, Exception('test done'))
def _get(self): from selenium import webdriver if self._timeout is not None: gevent.kill(self._timeout) self._timeout = None if self._driver is None: _log.info('create driver') options = webdriver.ChromeOptions() options.debugger_address = conf.chromeAddress self._driver = webdriver.Chrome(chrome_options=options) self._driver.implicitly_wait(30) # wait at most 30 seconds return self._driver
def test_csv_stats_writer_full_history(self): stats_writer = StatsCSVFileWriter(self.environment, PERCENTILES_TO_REPORT, self.STATS_BASE_NAME, full_history=True) for i in range(10): self.runner.stats.log_request("GET", "/", 100, content_length=666) greenlet = gevent.spawn(stats_writer) gevent.sleep(10) for i in range(10): self.runner.stats.log_request("GET", "/", 10, content_length=666) gevent.sleep(5) gevent.sleep(_TEST_CSV_STATS_INTERVAL_WAIT_SEC) gevent.kill(greenlet) stats_writer.close_files() self.assertTrue(os.path.exists(self.STATS_FILENAME)) self.assertTrue(os.path.exists(self.STATS_HISTORY_FILENAME)) self.assertTrue(os.path.exists(self.STATS_FAILURES_FILENAME)) self.assertTrue(os.path.exists(self.STATS_EXCEPTIONS_FILENAME)) with open(self.STATS_HISTORY_FILENAME) as f: reader = csv.DictReader(f) rows = [r for r in reader] self.assertGreaterEqual(len(rows), 130) self.assertEqual("/", rows[0]["Name"]) self.assertEqual("Aggregated", rows[1]["Name"]) self.assertEqual("/", rows[2]["Name"]) self.assertEqual("Aggregated", rows[3]["Name"]) self.assertEqual("20", rows[-1]["Total Request Count"]) saw100 = False saw10 = False for row in rows: if not saw100 and row["95%"] == "100": saw100 = True elif saw100 and row["95%"] == "10": saw10 = True break self.assertTrue(saw100, "Never saw 95th percentile increase to 100") self.assertTrue(saw10, "Never saw 95th percentile decrease to 10")
def shutdown(self): gevent.kill(self.input_loop) gevent.idle() self.worker_collection.shutdown_workers() self.logger.info("Waiting for all workers to shutdown...") while len(self.worker_collection.workers) > 0: self.logger.debug("{num} worker(s) still active".format(num=len(self.worker_collection.workers))) gevent.sleep(1) self.logger.info("Waiting for all responses to be delivered...") while self.response_queue.unfinished_tasks > 0: self.logger.debug("{num} responses to be delivered".format(num=self.response_queue.unfinished_tasks)) gevent.sleep(1) gevent.kill(self.output_loop) self.logger.info("ActionHandler shut down, {num} actions processed".format(num=next(self.counter)-1))
def test_stats_history(self): env1 = Environment(events=locust.events, catch_exceptions=False) runner1 = env1.create_master_runner("127.0.0.1", 5558) env2 = Environment(events=locust.events, catch_exceptions=False) runner2 = env2.create_worker_runner("127.0.0.1", 5558) greenlet1 = gevent.spawn(stats_history, runner1) greenlet2 = gevent.spawn(stats_history, runner2) gevent.sleep(1) hs1 = runner1.stats.history hs2 = runner2.stats.history gevent.kill(greenlet1) gevent.kill(greenlet2) self.assertEqual(1, len(hs1)) self.assertEqual(0, len(hs2))
def setup_posix(self): """ Setup for headset on the Linux platform. Receives packets from headset and sends them to a Queue to be processed by the crypto greenlet. """ _os_decryption = False if os.path.exists('/dev/eeg/raw'): # The decryption is handled by the Linux epoc daemon. We don't need to handle it. _os_decryption = True hidraw = open("/dev/eeg/raw") else: serial, hidraw_filename = get_linux_setup() #error line self.serial_number = serial if os.path.exists("/dev/" + hidraw_filename): print('os.path.exists') hidraw = open("/dev/" + hidraw_filename) else: #doesn't go here hidraw = open("/dev/hidraw4") crypto = gevent.spawn(self.setup_crypto, self.serial_number) print('crypto line 430') console_updater = gevent.spawn(self.update_console) print('console_updater line 432') while self.running: try: data = hidraw.read(32) #doesn't execute, stops print('running line 435') if data != "": print( 'data still in queue (still coming from headset) line 438' ) if _os_decryption: self.packets.put_nowait(EmotivPacket(data)) else: #Queue it! self.packets_received += 1 tasks.put_nowait(data) gevent.sleep(0) else: print('no new data from device line 454') # No new data from the device; yield # We cannot sleep(0) here because that would go 100% CPU if both queues are empty gevent.sleep(DEVICE_POLL_INTERVAL) except KeyboardInterrupt: print('not running') self.running = False hidraw.close() if not _os_decryption: gevent.kill(crypto, KeyboardInterrupt) gevent.kill(console_updater, KeyboardInterrupt)
def send_104frame(self, frame): # send s_frame if frame.name == "s_frame": frame.RecvSeq = self.rsn if self.t2_caller: gevent.kill(self.t2_caller) self.telegram_count = 0 response_string = (" ".join(hex(n) for n in frame.build())) logger.info('%s <--- s_frame %s (%s)', self.address, response_string, self.session_id) return frame.build() # send i_frame elif frame.name == "i_frame": if self.allow_DT: if self.t2_caller: gevent.kill(self.t2_caller) frame.SendSeq = self.ssn frame.RecvSeq = self.rsn self.increment_sendseq() self.telegram_count = 0 iframe = frame_object_with_timer(frame) self.sentmsgs.append(iframe) iframe.restart_t1() response_string = (" ".join(hex(n) for n in frame.build())) logger.debug('%s <--- i_frame %s (%s)', self.address, response_string, self.session_id) logger.info('%s <--- i_frame %s (%s)', self.address, frame.payload, self.session_id) return frame.build() else: logger.info("StartDT missing, buffer data. (%s)", self.session_id) # Limitation for buffer, arbitrary number if len(self.send_buffer) < 50: self.send_buffer.append(frame) # send u_frame elif frame.name == "u_frame": if frame.getfieldval("Type") == 0x07 or frame.getfieldval( "Type") == 0x43: uframe = frame_object_with_timer(frame) self.sentmsgs.append(uframe) uframe.restart_t1() response_string = (" ".join(hex(n) for n in frame.build())) logger.info('%s <--- u_frame %s (%s)', self.address, response_string, self.session_id) return frame.build()
def keepalive_token(self, token_id): token = self.lookup_token(token_id) if not token: raise TokenException('Token not found or expired') if token.lifetime: gevent.kill(token.timer) if token.revocation_function is not None: token.timer = gevent.spawn_later(token.lifetime, token.revocation_function, token.revocation_reason) else: token.timer = gevent.spawn_later(token.lifetime, self.revoke_token, token_id)
def subscribe_socket(ws): """Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket """ # XXX: TODO IMPLEMENT ME client = pool.add() group = gevent.spawn(read_ws, ws, client) try: while True: ws.send(client.get()) except Exception: pass # whatever finally: pool.remove(client) gevent.kill(group) return None
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' client = Client() websocket_clients.append(client) g = gevent.spawn(read_ws, ws, client) try: while True: message = client.get() ws.send(message) except Exception as e: print("WS Error %s" % e) finally: websocket_clients.remove(client) gevent.kill(g)
def _receive(self, event): if event.op_code == 10: self.print('hello received') self.heartbeat_interval = event.payload['heartbeat_interval'] / 1000 if self._ping_greenlet: gevent.killall([self._ping_greenlet]) self._ping_greenlet = gevent.spawn(self.ping) self.print(f'ping began with {self.heartbeat_interval} interval') elif event.op_code == 1: self.print('ping required') self.ws.send(11, None) elif event.op_code == 11: self.print('ping ack received') gevent.kill(self._ack_timeout)
def _rimt(exc): _logger.info('YELLOW<<killing main thread greenlet>>') main_thread_greenlet = threading.main_thread()._greenlet orig_throw = main_thread_greenlet.throw # we must override "throw" method so exception will be raised with the original traceback def throw(*args): if len(args) == 1: ex = args[0] return orig_throw(ex.__class__, ex, ex.__traceback__) return orig_throw(*args) main_thread_greenlet.throw = throw gevent.kill(main_thread_greenlet, exc) _logger.debug('exiting the thread that failed') raise exc
def watch_for_unlock_failures(*apps, retry_timeout=DEFAULT_RETRY_TIMEOUT): """ Context manager to assure there are no failing unlocks during transfers in integration tests. """ def watcher_function(): while True: for app in apps: assert not has_unlock_failure(app.raiden) gevent.sleep(retry_timeout) watcher = gevent.spawn(watcher_function) try: yield finally: gevent.kill(watcher)
def subscribe_socket(ws): listener = Listener() myWorld.add_set_listener(listener) g = gevent.spawn(read_ws, ws, listener) # listener thread try: while True: # block here msg = listener.get() print(msg) ws.send(msg) except Exception as e: # WebSocketError as e: print("WS Error %s" % e) finally: myWorld.listeners.remove(listener) gevent.kill(g)
def delete_token(self, token_id): if isinstance(token_id, Token): token = token_id token_id = self.lookup_token_id(token) else: token = self.lookup_token(token_id) if not token: logger.trace('Tried to delete token but it was not found or expired') return if token.lifetime: gevent.kill(token.timer) token.revocation_reason = 'Token explicitly deleted' token.revocation_function(self, token, token_id) else: self.tokens.pop(token)
def test_polling(self): transport = XHRPollingTransport(host="127.0.0.1", port=self.port, path="/socket.io/") context = {} def on_packet(packet): context['packet'] = packet transport.on('packet', on_packet) job = gevent.spawn(transport.poll) gevent.sleep(.5) self.assertIsNotNone(context['packet']) gevent.kill(job)
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' # XXX: TODO IMPLEMENT ME client = Client() Clients.append(client) gev = gevent.spawn(read_ws, ws, client) try: while True: ws.send(client.get()) except Exception as e: print(e) finally: Clients.remove(clinet) gevent.kill(gev)
def test_csv_stats_writer(self): greenlet = gevent.spawn(stats_writer, self.environment, self.STATS_BASE_NAME) gevent.sleep(0.21) gevent.kill(greenlet) self.assertTrue(os.path.exists(self.STATS_FILENAME)) self.assertTrue(os.path.exists(self.STATS_HISTORY_FILENAME)) self.assertTrue(os.path.exists(self.STATS_FAILURES_FILENAME)) with open(self.STATS_HISTORY_FILENAME) as f: reader = csv.DictReader(f) rows = [r for r in reader] self.assertEqual(2, len(rows)) self.assertEqual("Aggregated", rows[0]["Name"]) self.assertEqual("Aggregated", rows[1]["Name"])
def send_frame_imm(self, frame): # send s_frame if frame.name == "s_frame": frame.RecvSeq = self.rsn if self.t2_caller: gevent.kill(self.t2_caller) self.telegram_count = 0 response_string = " ".join(hex(n) for n in frame.build()) logger.info( "%s <--- s_frame %s (%s)", self.address, response_string, self.session_id, ) return self.sock.send(frame.build())
def test_run(self): # confirm server is offline with self.assertRaises(requests.exceptions.ConnectionError): requests.get('http://localhost:8080') # start and query server greenlet = gevent.Greenlet(run=self.engine.run) greenlet.start() ret = requests.get('http://localhost:8080') self.assertIsNotNone(ret) # confirm server is offline again gevent.kill(greenlet) with self.assertRaises(requests.exceptions.ConnectionError): requests.get('http://localhost:8080')
def gen(username): if username in pollers: del pollers[username] my_queue = gevent.queue.Queue() my_poller = greenlet.Greenlet.spawn(poller.poller_function, username, my_queue) pollers[username] = my_poller try: while True: yield str(my_queue.get()) except GeneratorExit: # Or maybe use flask signals gevent.kill(my_poller) del pollers[username]
def destroy(self): if self.connected: log.debug("Disconnecting") self.role.stack.disconnect() self.role = None if self.socket_handler is not None: log.debug("Connection quit(), killing remaining connection threads") gevent.kill(self.socket_handler_thread) self.socket_handler = None self.socket_handler_thread = None if self.event_handler is not None: self.event_handler.__del__() self.event_handler = None
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' # XXX: TODO IMPLEMENT ME g = gevent.spawn(read_ws, ws, myWorld.world()) print("Subscribing") try: msg = json.dumps(myWorld.world()) print("Got world: %s" % msg) ws.send(msg) except Exception as e: print('WS Error %s' % e) finally: gevent.kill(g) return None
def test_2_workers_wait_1_job(self): g1 = gevent.spawn(self.pull) g2 = gevent.spawn(self.pull) gevent.idle() self.assertEqual(self.post(['foo']), [1]) ready_greenlets = gevent.joinall([g1, g2], timeout=0.2) self.assertEqual(len(ready_greenlets), 1) g = ready_greenlets[0] messages = g.get() self.assertDictContainsSubset({'id': 1, 'message': 'foo'}, messages[0]) if g == g1: g = g2 else: g = g1 gevent.kill(g)
def initial_sync_impl(self, crispin_client): # We wrap the block in a try/finally because the change_poller greenlet # needs to be killed when this greenlet is interrupted change_poller = None try: assert crispin_client.selected_folder_name == self.folder_name remote_uids = crispin_client.all_uids() with self.syncmanager_lock: with session_scope(self.namespace_id) as db_session: local_uids = common.local_uids(self.account_id, db_session, self.folder_id) common.remove_deleted_uids( self.account_id, self.folder_id, set(local_uids).difference(remote_uids), ) new_uids = set(remote_uids).difference(local_uids) with session_scope(self.namespace_id) as db_session: account = db_session.query(Account).get(self.account_id) throttled = account.throttled self.update_uid_counts( db_session, remote_uid_count=len(remote_uids), # This is the initial size of our download_queue download_uid_count=len(new_uids), ) change_poller = gevent.spawn(self.poll_for_changes) bind_context(change_poller, "changepoller", self.account_id, self.folder_id) uids = sorted(new_uids, reverse=True) for count, uid in enumerate(uids, start=1): # The speedup from batching appears to be less clear for # non-Gmail accounts, so for now just download one-at-a-time. self.download_and_commit_uids(crispin_client, [uid]) self.heartbeat_status.publish() if throttled and count >= THROTTLE_COUNT: # Throttled accounts' folders sync at a rate of # 1 message/ minute, after the first approx. THROTTLE_COUNT # messages per folder are synced. # Note this is an approx. limit since we use the #(uids), # not the #(messages). gevent.sleep(THROTTLE_WAIT) finally: if change_poller is not None: # schedule change_poller to die gevent.kill(change_poller)
def test_return_values(default_settings, sim_action, return_type): default_settings['exec_numSlotframesPerRun'] = 1 if sim_action == 'start': if return_type == 'success': # use the default settings; do nothing pass elif return_type == 'failure_on_sim_existence': # set a dummy object to _sim_engine backend.sim._sim_engine = {} else: # make an error in settings del default_settings['exec_numMotes'] ret_val = backend.sim.start(default_settings, stderr_redirect=False) if return_type == 'failure_on_sim_existence': # revert _sim_engine backend.sim._sim_engine = None else: assert backend.sim._sim_engine is None else: method_to_call = getattr(backend.sim, sim_action) greenlet = gevent.spawn(backend.sim.start, default_settings) if return_type == 'success': # start a simulation gevent.sleep(backend.sim.GEVENT_SLEEP_SECONDS_IN_SIM_ENGINE) if sim_action == 'resume': # make the simulation pause backend.sim.pause() else: # do nothing; _sim_engine is not available yet pass ret_val = method_to_call() if backend.sim._sim_engine is not None: backend.sim._destroy_sim() gevent.kill(greenlet) assert backend.sim._sim_engine is None if return_type == 'success': assert ret_val['status'] == backend.sim.RETURN_STATUS_SUCCESS assert 'message' not in ret_val assert 'trace' not in ret_val else: assert ret_val['status'] == backend.sim.RETURN_STATUS_FAILURE assert ret_val['message'] is not None
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' client = Client() clients.append(client) g = gevent.spawn( read_ws, ws, client ) try: while True: # block here msg = client.get() ws.send(msg) except Exception as e:# WebSocketError as e: print(f"WS Error {e}") finally: clients.remove(client) gevent.kill(g)
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' # XXX: TODO IMPLEMENT ME client = Client() clients.append(client) g = gevent.spawn(read_ws, ws, client) try: while True: msg = client.get() ws.send(msg) except Exception as e: print "WS Error %s" % e finally: clients.remove(client) gevent.kill(g)
def subscribe_socket(ws): '''Fufill the websocket URL of /subscribe, every update notify the websocket and read updates from the websocket ''' listener = Listener() myWorld.add_set_listener(listener) g = gevent.spawn(read_ws, ws, listener) try: while True: msg = listener.get() ws.send(msg) except Exception as e: # WebSocketError as e: print("WS Error %s" % e) finally: gevent.kill(g)