def application(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) gevent.spawn(level1) for i in range(100): yield "counter: %d<br/>" % i
def communicate(self, input=None): if self.stdin is not None: def _writer(): self.stdin.write(input) self.stdin.close() writer = gevent.spawn(_writer) if self.stdout is not None: reader_stdout = gevent.spawn(self.stdout.read) if self.stderr is not None: reader_stderr = gevent.spawn(self.stderr.read) stdoutdata = None if self.stdout is not None: stdoutdata = reader_stdout.get() stderrdata = None if self.stderr is not None: stderrdata = reader_stderr.get() if self.stdin: writer.get() self.wait() return (stdoutdata, stderrdata)
def main(): gevent.joinall([ gevent.spawn(setter), gevent.spawn(waiter), gevent.spawn(waiter), gevent.spawn(waiter) ])
def startRedis(): '''连接Redis服务器''' if not Gcore.startedRedis: from sgLib.pyRedis import MyRedis #连到本服 #print 'connect redisL',Gcore.config.REDISL_HOST,Gcore.config.REDISL_PORT Gcore.redisL = MyRedis(host=Gcore.config.REDISL_HOST, port=Gcore.config.REDISL_PORT, password=Gcore.config.REDISL_PWD) Gcore.redisL.start('redisL') gevent.spawn(Gcore.redisL.loop) if Gcore.config.REDISL_HOST != Gcore.config.REDISM_HOST and Gcore.loadCoreCfg('CrossServer')!='0': #连到总服 print '连到总服redis...' #print 'connect redisM',Gcore.config.REDISM_HOST,Gcore.config.REDISM_PORT Gcore.redisM = MyRedis(host=Gcore.config.REDISM_HOST, port=Gcore.config.REDISM_PORT, password=Gcore.config.REDISM_PWD) Gcore.redisM.start('redisM') gevent.spawn(Gcore.redisM.loop) else: Gcore.redisM = Gcore.redisL if 0: print 'redisL',Gcore.redisL.get('foo') print 'redisM',Gcore.redisM.get('foo') Gcore.startedRedis = True
def _do_socket(socket): socket.send('server started') socket.send(json.dumps(dict(request.cookies))) def _ping(): while True: time.sleep(60) try: socket.send('ping!') except websocket.Error: break def _env(): for k, v in sorted(socket.environ.iteritems()): time.sleep(1) try: socket.send('%s: %r' % (k, v)) except websocket.Error: break def _echo(): while True: msg = socket.recv() if not msg: break socket.send(msg[::-1]) tasks = [gevent.spawn(_ping), gevent.spawn(_echo)] for task in tasks: task.join()
def test_del_closes_socket(self): if PYPY: return timer = gevent.Timeout.start_new(0.5) def accept_once(listener): # delete/overwrite the original conn # object, only keeping the file object around # closing the file object should close everything try: conn, addr = listener.accept() conn = conn.makefile(mode='wb') conn.write(b'hello\n') conn.close() _write_to_closed(conn, b'a') finally: listener.close() server = tcp_listener(('0.0.0.0', 0)) gevent.spawn(accept_once, server) client = socket.create_connection(('127.0.0.1', server.getsockname()[1])) fd = client.makefile() client.close() assert fd.read() == 'hello\n' assert fd.read() == '' timer.cancel()
def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(('', 80)) s.listen(1) while True: conn, addr = s.accept() gevent.spawn(lambda: handle_client(conn, addr))
def needFile(self, inner_path, update=False, blocking=True, peer=None, priority=0): if self.storage.isFile(inner_path) and not update: # File exist, no need to do anything return True elif self.settings["serving"] is False: # Site not serving return False else: # Wait until file downloaded self.bad_files[inner_path] = self.bad_files.get(inner_path, 0) + 1 # Mark as bad file if not self.content_manager.contents.get("content.json"): # No content.json, download it first! self.log.debug("Need content.json first") gevent.spawn(self.announce) if inner_path != "content.json": # Prevent double download task = self.worker_manager.addTask("content.json", peer) task.get() self.content_manager.loadContent() if not self.content_manager.contents.get("content.json"): return False # Content.json download failed if not inner_path.endswith("content.json") and not self.content_manager.getFileInfo(inner_path): # No info for file, download all content.json first self.log.debug("No info for %s, waiting for all content.json" % inner_path) success = self.downloadContent("content.json", download_files=False) if not success: return False if not self.content_manager.getFileInfo(inner_path): return False # Still no info for file task = self.worker_manager.addTask(inner_path, peer, priority=priority) if blocking: return task.get() else: return task
def send_email(self, from_address, to_addresses, subject, message): """ RPC Method allowing a platform to send an email address. One can also send an email through the pubsub mechanism. :param from_address: :param to_addresses: :param subject: :param message: """ _log.info('Sending email {}'.format(subject)) _log.debug('Mail from: {}, to: {}'.format(from_address, to_addresses)) recipients = to_addresses if isinstance(recipients, basestring): recipients = [recipients] # Use unicode to protect against encod error # http://stackoverflow.com/questions/25891541/attributeerror-encode msg = MIMEText(unicode(message)) msg['To'] = ', '.join(recipients) msg['FROM'] = from_address msg['Subject'] = subject gevent.spawn(self._send_email, from_address, recipients, msg) gevent.sleep(0.1)
def get(self, protocol='default'): D = self.failsafe_json_decode args = dict([(k, D(v[0])) for k, v in self.request.arguments.iteritems()]) fn = args.pop('fn') m = dict(kwargs=args, fn=fn, args=[]) gevent.spawn(lambda: self._handle_call(self.request, fn, m, protocol))
def do_job(self, task_file, split_size, num_reducer, input_file, output_file): self.output_file = output_file # identical name for each task # use this name to generate intermediate filename task_name = time.strftime("%Y%m%d%H%M%S", time.localtime()) self.task_name = task_name print "Task %s get" % task_file[0] start_time = datetime.now() split_size = int(split_size) num_reducer = int(num_reducer) split_infos, file_info = self.split_file(split_size, input_file) num_mapper = len(split_infos) # initialize jobs_tracker for task_name self.jobs_tracker[task_name] = {"mappers": {}, "reducers": {}, "num_mapper": num_mapper, "num_reducer": num_reducer, "task_file": task_file, "split_infos": split_infos, "file_info": file_info, "output_file": output_file, "split_size": split_size, "done": False} print "Task " + task_name + " : assigning %d mappers, %d reducers" % (num_mapper, num_reducer) # Map task mapper_procs = gevent.spawn(self.assign_mappers, task_name) mapper_procs.join() # Reduce task reducer_procs = gevent.spawn(self.assign_reducers, task_name) reducer_procs.join() print "Task finished" end_time = datetime.now() print('Duration: {}'.format(end_time - start_time))
def _dispatch_send(self, message): """ Dispatch the different steps of sending """ if self.dryrun: return message if not self.socket: raise GraphiteSendException( "Socket was not created before send" ) sending_function = self._send if self._autoreconnect: sending_function = self._send_and_reconnect try: if self.asynchronous and gevent: gevent.spawn(sending_function, message) else: sending_function(message) except Exception as e: self._handle_send_error(e) return "sent {0} long message: {1}".format(len(message), message[:75])
def start(self): #1.读取所有报警配置项 db = self.getDBConn() cr = db.cursor() # sql="select * from giscore_AO_UserAlarmSettings where enable=true order by ao_id" sql = "select * from giscore_activeobject" cr.execute(sql) aos = dbconn.fetchallDict(cr) for ao in aos: sql = "select a.*,b.activeobject_id as aoid,c.name as aoname from \ giscore_AO_UserAlarmSettings a,\ giscore_activeobject_alarmsettings b, \ giscore_activeobject c \ where \ a.id = b.ao_useralarmsettings_id \ and b.activeobject_id=%s and \ b.activeobject_id= c.id and \ a.enable=true"%(ao['id']) cr.execute(sql) rs = dbconn.fetchallDict(cr) for r in rs: #每个报警配置项处理 asi = AlarmSettingItem(self) if asi.init(r): self.asis.append( asi ) ### # thread = threading.Thread(target=self.thread_check) # thread.start() import gevent gevent.spawn(self.thread_check)
def when_ready(server): def monitor(): modify_times = {} while True: for module in sys.modules.values(): path = getattr(module, "__file__", None) if not path: continue if path.endswith(".pyc") or path.endswith(".pyo"): path = path[:-1] try: modified = os.stat(path).st_mtime except: continue if path not in modify_times: modify_times[path] = modified continue if modify_times[path] != modified: logging.info("%s modified; restarting server", path) os.kill(os.getpid(), signal.SIGHUP) modify_times = {} break gevent.sleep(1) import gevent gevent.spawn(monitor)
def test_fullduplex(self): def server(): (client, addr) = self.listener.accept() # start reading, then, while reading, start writing. the reader should not hang forever N = 100000 # must be a big enough number so that sendall calls trampoline sender = gevent.spawn(client.sendall, 't' * N) result = client.recv(1000) assert result == 'hello world', result sender.join(timeout=0.2) sender.kill() sender.get() #print '%s: client' % getcurrent() server_proc = gevent.spawn(server) client = self.create_connection() client_reader = gevent.spawn(client.makefile().read) gevent.sleep(0.001) client.send('hello world') # close() used to hang client.close() # this tests "full duplex" bug; server_proc.get() client_reader.get()
def test_concurency(server_port): s = tcp.Command("127.0.0.1", server_port) s.connect() def task_function(msg, i): assert s.write_readline(msg + '\n') == msg def task_with_exception(msg, i): msg += '_exception' try: transaction = s._write(msg) s._readline(transaction, timeout=0.01, eol='\r', clear_transaction=False) except RuntimeError: # timeout rxmsg = s._read(transaction, size=len(msg)) assert rxmsg == msg tasks = [] for i, msg in enumerate(['HELLO', 'WORLD', 'HOUPPI', 'tagada', 'super', 'mario', 'ludgi']): tasks.append(gevent.spawn(task_function, msg, i)) if i % 2: tasks.append(gevent.spawn(task_with_exception, msg, i)) for t in tasks: t.join(3)
def test_rcp_streaming(): endpoint = random_ipc_endpoint() class MySrv(zerorpc.Server): @zerorpc.rep def range(self, max): return xrange(max) @zerorpc.stream def xrange(self, max): return xrange(max) srv = MySrv(heartbeat=2) srv.bind(endpoint) gevent.spawn(srv.run) client = zerorpc.Client(heartbeat=2) client.connect(endpoint) r = client.range(10) assert r == tuple(range(10)) r = client.xrange(10) assert getattr(r, 'next', None) is not None l = [] print 'wait 4s for fun' gevent.sleep(4) for x in r: l.append(x) assert l == range(10)
def __init__(self): self.log = logging.getLogger("SiteManager") self.log.debug("SiteManager created.") self.sites = None self.loaded = False gevent.spawn(self.saveTimer) atexit.register(self.save)
def put(self, *args, **kwargs): """ This is design to hanlde 3 situation 1. Can pass just the key as the first argument and call put on queue that is returned. 2. Pass key as fist argument and callback as second which will be called in a coroutine (or thread). 3. Pass key as first argument and callback as second and the rest of the arguments and keywords will be passed to the callback. """ key = args[0] callback = None args = args[1:] if len(args) > 0: callback = args[0] args = args[1:] q = Queue() dict.__setitem__(self, key, q) if callback: def handle(): if args: q.put(callback(*args)) elif not args and kwargs: q.put(callback(*args, **kwargs)) else: q.put(callback(*args, **kwargs)) spawn(handle) return q
def spawn_asyncresult(fn, *args, **kwargs): """ Spawn a Greenlet and pass it's results to an AsyncResult. This function is useful to shuffle data from a Greenlet to AsyncResult, which then again is useful because any Greenlets that raise exceptions will cause tracebacks to be shown on stderr by gevent, even when ``.link_exception`` has been called. Using an AsyncResult avoids this. """ r = gevent.event.AsyncResult() def wrapper(): """ Internal wrapper. """ try: value = fn(*args, **kwargs) except Exception as e: r.set_exception(e) else: r.set(value) gevent.spawn(wrapper) return r
def _disconnect_timeout(self): self.timeout.clear() if self.timeout.wait(10.0): gevent.spawn(self._disconnect_timeout) else: self.kill()
def get_response(self, parameters={}, url=SEARCH_ADRES_URL): """ Actualy do the http api search call """ # parameters = {'q': self.get_q()} async_r = grequests.get(url, params=parameters, session=self.session) # send a request and wait for results gevent.spawn(async_r.send).join() # Do something with the result count? if async_r.response is None: log.error('RESPONSE NONE %s %s', url, parameters) return {} if async_r.response.status_code == 404: log.error('404 %s %s', url, parameters) return {} if not async_r.response: log.error('NO RESPONSE %s %s', url, parameters) return {} result_json = async_r.response.json() return result_json
def server(env, start_response): start_response("200 OK", [("Content-Type", "text/html")]) path = env["PATH_INFO"] queryString = env["QUERY_STRING"] if path == GET_DOMAIN_URL: domain = redisConnection.spop(screenshotsQueueKey) if domain: return [domain] else: return ["empty"] if path == RESIZE_URL: query = parse_qs(urlparse("?" + queryString).query) screenshotsJson = query["screenshots"][0] domain = query["domain"][0] screenshotsJson = urllib2.unquote(screenshotsJson) redisConnection.sadd(resizeQueueKey, "%s@%s" % (domain, screenshotsJson)) return ["okay"] if path == CREATE_SCREENSHOT: screenshots = queue.Queue() try: queryKey, domain = queryString.split("=") except Exception: return ["error"] redisConnection.sadd(screenshotsQueueKey, domain) gevent.spawn(waitForScreenshot, domain, screenshots) print "return screenshots to the client" return screenshots return ["error"]
def main(): if len(sys.argv) > 1: code = sys.argv[1] print 'stock code %s' % (code) global TID TID = code with open('robot.yaml') as f: cfg = yaml.load(f) rip = cfg['robot_listen']['rip'] rport = cfg['robot_listen']['rport'] addr = (rip, rport) print addr tester = Tester(TID, addr) pq_ip = cfg['pre_quo']['pqip'] pq_port = cfg['pre_quo']['port'] print pq_ip, pq_port pre_quo = pre_quotation.PreQuotation(tester, (pq_ip, pq_port)) tester.pre_quo = pre_quo q_ip = cfg['quo_server']['qip'] q_port = cfg['quo_server']['port'] print q_ip, q_port quota = quotation.Quotation(tester, (q_ip, q_port)) tester.quo = quota jobs = [] jobs.append(gevent.spawn(pre_quo.recv_data)) jobs.append(gevent.spawn(quota.recv_data)) jobs.append(gevent.spawn(tester.recv_data)) gevent.joinall(jobs) return 0
def on_message(self, msg): if logger.isEnabledFor(logging.DEBUG): logger.debug('Got broker message:[{}]'.format(msg)) if msg.type == 'message': # Replace payload with stuff read off the KVDB in case this is where the actual message happens to reside. if msg.channel in NEEDS_TMP_KEY: tmp_key = '{}.tmp'.format(msg.data) if self.lua_container.run_lua('zato.rename_if_exists', [msg.data, tmp_key]) == CODE_NO_SUCH_FROM_KEY: payload = None else: payload = self.kvdb.conn.get(tmp_key) self.kvdb.conn.delete(tmp_key) # Note that it would've expired anyway if not payload: logger.warning('No KVDB payload for key [{}] (already expired?)'.format(tmp_key)) else: payload = loads(payload) else: payload = loads(msg.data) if payload: payload = Bunch(payload) if logger.isEnabledFor(logging.DEBUG): logger.debug('Got broker message payload [{}]'.format(payload)) callback = self.topic_callbacks[msg.channel] spawn(callback, payload) else: if logger.isEnabledFor(logging.DEBUG): logger.debug('No payload in msg:[{}]'.format(msg))
def InstanceClient(host, port): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect((host, port)) except: raise else: socketName = s.getsockname() def handle_incoming_data(client_socket): buffer = "" while True: data = client_socket.recv(1024) if data == "": INSTANCE_HO.serverClosed() break buffer += data msgs = buffer.split(TERMINATOR) buffer = msgs.pop() for msg in msgs: INSTANCE_HO.clientMessageReceived(msg) CLIENTS[socketName] = s gevent.spawn(handle_incoming_data, s) return socketName
def _run(self): """Main loop; reap and process pkts""" try: args = self.orbname, self.select, self.reject print repr(self.orbname) print repr(args) with OrbreapThr(*args, timeout=1, queuesize=8, after=self.tafter) as orbreapthr: log.info("Connected to ORB %s %s %s" % (self.orbname, self.select, self.reject)) self.timeoff = self.timeon = datetime.utcnow() spawn(self._status_printer).link_exception(self._janitor) threadpool = ThreadPool(maxsize=1) try: while True: try: success, value = threadpool.spawn( wrap_errors, (Exception,), orbreapthr.get, [], {}).get() timestamp = datetime.utcnow() if not success: raise value except (Timeout, NoData), e: log.debug("orbreapthr.get exception %r" % type(e)) pass else: if value is None: raise Exception('Nothing to publish') self._process(value, timestamp) finally: # This blocks until all threads in the pool return. That's # critical; if the orbreapthr dies before the get thread, # segfaults ensue. threadpool.kill() except Exception, e: log.error("OrbPktSrc terminating due to exception", exc_info=True) raise
def go(): app = get_app() app.debug = debug if app.debug: app.config.update(SEND_FILE_MAX_AGE_DEFAULT=0) # TODO: asset debug settings will cause bad YSLOW rating app.config['COMPRESS_DEBUG'] = False app.config['ASSETS_DEBUG'] = debug # Breaks web socket communication # (WebSocketConnectionClosedException in client) # app = DebuggedApplication(app, evalex=True) host = conf_global['serverHost'] port = conf_global['serverPort'] print('Server: {0}:{1}'.format(host, port)) http_server = WSGIServer((host, port), app, handler_class=WebSocketHandler) # gevent.spawn(send_dummy_notifications) gevent.spawn(send_bulk) http_server.serve_forever()
def test_multiple_waiters(self): # tests that multiple waiters get their results back q = queue.Queue() def waiter(q, evt): evt.set(q.get()) sendings = ['1', '2', '3', '4'] evts = [AsyncResult() for x in sendings] for i, x in enumerate(sendings): gevent.spawn(waiter, q, evts[i]) # XXX use waitall for them gevent.sleep(0.01) # get 'em all waiting results = set() def collect_pending_results(): for e in evts: with gevent.Timeout(0.001, False): x = e.get() results.add(x) return len(results) q.put(sendings[0]) self.assertEquals(collect_pending_results(), 1) q.put(sendings[1]) self.assertEquals(collect_pending_results(), 2) q.put(sendings[2]) q.put(sendings[3]) self.assertEquals(collect_pending_results(), 4)
def test_multiple_listeners_error(self): # if there was an error while calling a callback # it should not prevent the other listeners from being called # also, all of the errors should be logged, check the output # manually that they are p = gevent.spawn(lambda: 5) results = [] def listener1(*args): results.append(10) raise ExpectedError('listener1') def listener2(*args): results.append(20) raise ExpectedError('listener2') def listener3(*args): raise ExpectedError('listener3') p.link(listener1) p.link(listener2) p.link(listener3) sleep(DELAY * 10) assert results in [[10, 20], [20, 10]], results p = gevent.spawn(lambda: getcurrent().throw(ExpectedError('test_multiple_listeners_error'))) results = [] p.link(listener1) p.link(listener2) p.link(listener3) sleep(DELAY * 10) assert results in [[10, 20], [20, 10]], results
'Accept-Charset': 'ZWNobyAiZWVTenh1OTJuSURBYiI7IA==', # 输出 eeSzxu92nIDAb 'Accept-Encoding': 'gzip,deflate', 'Accept-Language': 'zh-CN,zh;q=0.9', } try: #print(url) res = rq.get(url, headers=headers, timeout=3) if res.status_code == 200: res.text.find('eeSzxu92nIDAb') #print(res.text.find('eeSzxu92nIDAb')) if res.text.find('eeSzxu92nIDAb') > -1: print("[存在漏洞] " + url) f = open("ok.txt", "a") f.write("[存在漏洞] " + url + "\n") f.close() else: print("[不存在漏洞] " + url) except Exception as e: #raise e print("[超时] " + url) if __name__ == '__main__': print("phpStudy 批量检测 (需要 gevent,requests 库)") print("使用之前,请将URL保存为 url.txt 放置此程序同目录下") input("任意按键开始执行..") tasks = [gevent.spawn(check, url) for url in file_read()] print("正在执行...请等候") gevent.joinall(tasks) wait = input("执行完毕 任意键退出...")
def kill_game(self): if self.is_match and self.game.started: gevent.spawn(lambda: Subsystem.interconnect.publish( 'speaker', [u'文文', u'“%s”意外终止了!' % self.game_name])) self.game.suicide = True # game will kill itself in get_synctag()
import gevent from gevent import monkey import time monkey.patch_all() def f(n): for i in range(n): print(gevent.getcurrent(), i) #用来模拟一个耗时操作,注意不是time模块中的sleep time.sleep(1) g1 = gevent.spawn(f, 5) g2 = gevent.spawn(f, 5) g3 = gevent.spawn(f, 5) g1.join() g2.join() g3.join()
def main_comment(): greenlets = [] for i in range(20): mm = MuMian() greenlets.append(gevent.spawn(mm.get_comment)) gevent.joinall(greenlets)
def start(self) -> gevent.Greenlet: assert not self.main_loop_spawned, 'Tried to spawn the main loop twice' greenlet = gevent.spawn(self.main_loop) self.main_loop_spawned = True return greenlet
def stop(self, exit_exc=None, caller=None): spawn(self._stop)
# wang from urllib import request import gevent, time from gevent import monkey monkey.patch_all() def f(url): print('GET:{}'.format(url)) res = request.urlopen(url) date = res.read() print(len(date), url) sync_time = time.time() f('https://www.python.org/') #f('https://www.yahoo.com/') f('https://github.com/') print(time.time() - sync_time) rsync_time = time.time() gevent.joinall([ gevent.spawn(f, 'https://www.python.org/'), # gevent.spawn(f,'https://www.yahoo.com/'), gevent.spawn(f, 'https://github.com/') ]) print(time.time() - rsync_time)
def task(singer_type_list, type_href_list): gevent_list = [] for i in range(len(singer_type_list)): g = gevent.spawn(worker, *(singer_type_list[i], type_href_list[i])) gevent_list.append(g) gevent.joinall(gevent_list)
import gevent from gevent.queue import Queue tasks = Queue() def worker(user): while not tasks.empty(): task = tasks.get() print('%s got task %s' % (user, task)) gevent.sleep(0) print('Quitting worker!') def boss(): for i in xrange(4): tasks.put_nowait(i) gevent.spawn(boss).join() gevent.joinall([ gevent.spawn(worker, 'steve'), gevent.spawn(worker, 'john'), ])
def start(self): """ Start the node synchronously. Raises directly if anything went wrong on startup """ if not self.stop_event.ready(): raise RuntimeError(f'{self!r} already started') self.stop_event.clear() if self.database_dir is not None: self.db_lock.acquire(timeout=0) assert self.db_lock.is_locked # start the registration early to speed up the start if self.config['transport_type'] == 'udp': endpoint_registration_greenlet = gevent.spawn( self.discovery.register, self.address, self.config['transport']['udp']['external_ip'], self.config['transport']['udp']['external_port'], ) # The database may be :memory: storage = sqlite.SQLiteStorage(self.database_path, serialize.JSONSerializer()) self.wal = wal.restore_from_latest_snapshot( node.state_transition, storage, ) if self.wal.state_manager.current_state is None: log.debug( 'No recoverable state available, created inital state', node=pex(self.address), ) block_number = self.chain.block_number() state_change = ActionInitChain( random.Random(), block_number, self.chain.node_address, self.chain.network_id, ) self.wal.log_and_dispatch(state_change) payment_network = PaymentNetworkState( self.default_registry.address, [], # empty list of token network states as it's the node's startup ) state_change = ContractReceiveNewPaymentNetwork( constants.EMPTY_HASH, payment_network, ) self.handle_state_change(state_change) # On first run Raiden needs to fetch all events for the payment # network, to reconstruct all token network graphs and find opened # channels last_log_block_number = 0 else: # The `Block` state change is dispatched only after all the events # for that given block have been processed, filters can be safely # installed starting from this position without losing events. last_log_block_number = views.block_number( self.wal.state_manager.current_state) log.debug( 'Restored state from WAL', last_restored_block=last_log_block_number, node=pex(self.address), ) known_networks = views.get_payment_network_identifiers( views.state_from_raiden(self)) if known_networks and self.default_registry.address not in known_networks: configured_registry = pex(self.default_registry.address) known_registries = lpex(known_networks) raise RuntimeError( f'Token network address mismatch.\n' f'Raiden is configured to use the smart contract ' f'{configured_registry}, which conflicts with the current known ' f'smart contracts {known_registries}', ) # Clear ref cache & disable caching serialize.RaidenJSONDecoder.ref_cache.clear() serialize.RaidenJSONDecoder.cache_object_references = False # Restore the current snapshot group state_change_qty = self.wal.storage.count_state_changes() self.snapshot_group = state_change_qty // SNAPSHOT_STATE_CHANGES_COUNT # Install the filters using the correct from_block value, otherwise # blockchain logs can be lost. self.install_all_blockchain_filters( self.default_registry, self.default_secret_registry, last_log_block_number, ) # Complete the first_run of the alarm task and synchronize with the # blockchain since the last run. # # Notes about setup order: # - The filters must be polled after the node state has been primed, # otherwise the state changes won't have effect. # - The alarm must complete its first run before the transport is started, # to avoid rejecting messages for unknown channels. self.alarm.register_callback(self._callback_new_block) # alarm.first_run may process some new channel, which would start_health_check_for # a partner, that's why transport needs to be already started at this point self.transport.start(self) self.alarm.first_run() chain_state = views.state_from_raiden(self) # Dispatch pending transactions pending_transactions = views.get_pending_transactions(chain_state, ) log.debug( 'Processing pending transactions', num_pending_transactions=len(pending_transactions), node=pex(self.address), ) with self.dispatch_events_lock: for transaction in pending_transactions: try: self.raiden_event_handler.on_raiden_event( self, transaction) except RaidenRecoverableError as e: log.error(str(e)) self.alarm.start() # after transport and alarm is started, send queued messages events_queues = views.get_all_messagequeues(chain_state) for queue_identifier, event_queue in events_queues.items(): self.start_health_check_for(queue_identifier.recipient) # repopulate identifier_to_results for pending transfers for event in event_queue: if type(event) == SendDirectTransfer: self.identifier_to_results[ event.payment_identifier] = AsyncResult() message = message_from_sendevent(event, self.address) self.sign(message) self.transport.send_async(queue_identifier, message) # exceptions on these subtasks should crash the app and bubble up self.alarm.link_exception(self.on_error) self.transport.link_exception(self.on_error) # Health check needs the transport layer self.start_neighbours_healthcheck() if self.config['transport_type'] == 'udp': endpoint_registration_greenlet.get( ) # re-raise if exception occurred super().start()
def testExecuteWorker(self): import mars.tensor as mt mock_scheduler_addr = '127.0.0.1:%d' % get_next_port() try: session_id = str(uuid.uuid4()) with create_actor_pool(n_process=1, backend='gevent', address=mock_scheduler_addr) as pool: pool.create_actor(ClusterInfoActor, schedulers=[mock_scheduler_addr], uid=ClusterInfoActor.default_name()) pool.create_actor(ChunkMetaActor, uid=ChunkMetaActor.default_name()) resource_ref = pool.create_actor( ResourceActor, uid=ResourceActor.default_name()) proc = subprocess.Popen([ sys.executable, '-m', 'mars.worker', '-a', '127.0.0.1', '--schedulers', mock_scheduler_addr, '--cpu-procs', '1', '--cache-mem', '10m', '--ignore-avail-mem' ]) worker_ips = [] def waiter(): check_time = time.time() while True: if not resource_ref.get_workers_meta(): gevent.sleep(0.5) if proc.poll() is not None: raise SystemError('Worker dead. exit code %s' % proc.poll()) if time.time() - check_time > 20: raise SystemError( 'Check meta_timestamp timeout') continue else: break val = resource_ref.get_workers_meta() worker_ips.extend(val.keys()) gl = gevent.spawn(waiter) gl.join() a = mt.ones((100, 50), chunk_size=30) b = mt.ones((50, 200), chunk_size=30) result = a.dot(b) graph = result.build_graph(tiled=True) reply_ref = pool.create_actor(PromiseReplyTestActor) reply_callback = ((reply_ref.uid, reply_ref.address), 'reply') executor_ref = pool.actor_ref(ExecutionActor.default_name(), address=worker_ips[0]) io_meta = dict(chunks=[c.key for c in result.chunks]) executor_ref.execute_graph(session_id, str(id(graph)), serialize_graph(graph), io_meta, None, callback=reply_callback) check_time = time.time() while not reply_ref.get_reply(): gevent.sleep(0.1) if time.time() - check_time > 20: raise SystemError('Check reply timeout') finally: if proc.poll() is None: proc.send_signal(signal.SIGINT) check_time = time.time() while True: time.sleep(1) if proc.poll( ) is not None or time.time() - check_time >= 5: break if proc.poll() is None: proc.kill() if os.path.exists(options.worker.plasma_socket): os.unlink(options.worker.plasma_socket)
from gevent.queue import Queue, Empty tasks = Queue(maxsize=3) def worker(name): try: while True: task = tasks.get(timeout=1) print(('Worker %s got task %s' % (name, task))) gevent.sleep(0) except Empty: print(('Quitting time of %s!' % name)) def boss(): for i in range(1, 11): tasks.put(i) print('Assigned all work in iteration 1') for i in range(11, 21): tasks.put(i) print('Assigned all work in iteration 2') gevent.joinall([ gevent.spawn(boss), gevent.spawn(worker, 'steve'), gevent.spawn(worker, 'john'), gevent.spawn(worker, 'bob'), ])
def _update_tags_series_async_gevent(db, provider_name=None, dataset_code=None, max_bulk=100, update_only=False, dry_mode=False): import gevent from gevent.pool import Pool from gevent.queue import Queue pool = Pool(10) queue = Queue() count_errors = 0 count_success = 0 def _queue_process(): _requests = [] count_series = 0 count_modified = 0 def _process_requests(): result = db[constants.COL_SERIES].bulk_write(_requests, ordered=False, bypass_document_validation=True) return result.modified_count try: while True: _id, _tags = queue.get() if not _id: break count_series += 1 _requests.append(UpdateOne({'_id': _id}, {"$set": {'tags': _tags}})) if len(_requests) >= max_bulk: count_modified += _process_requests() _requests = [] finally: if len(_requests) > 0: count_modified += _process_requests() return count_series, count_modified doc_provider = db[constants.COL_PROVIDERS].find_one({"enable": True, "name": provider_name}) if not doc_provider: logger.error("Provider [%s] not found or disable." % provider_name) return dataset_query = {'provider_name': provider_name, "enable": True} dataset_projection = {"doc_href": False, "dimension_list": False, "attribute_list": False} if dataset_code: dataset_query["dataset_code"] = dataset_code def _series_list_process(doc_dataset): series_query = { "provider_name": doc_dataset["provider_name"], "dataset_code": doc_dataset["dataset_code"]} series_projection = {"values": False} if update_only: series_query["tags.0"] = {"$exists": False} _modified_count = 0 pool_series = Pool(200) def _serie_process(doc): select_for_tags = [tag for tag in generate_tags_series_async(doc, doc_provider, doc_dataset)] tags = [] for value in select_for_tags: tags.extend(str_to_tags(value)) queue.put((doc["_id"], sorted(list(set(tags))))) for doc in db[constants.COL_SERIES].find(series_query, series_projection): pool_series.spawn(_serie_process, doc) pool_series.join() def _process_ds(): count_ds = 0 for doc_dataset in db[constants.COL_DATASETS].find(dataset_query, dataset_projection): count_ds += 1 pool.spawn(_series_list_process, doc_dataset) pool.join() queue.put((None, None)) return count_ds queue_green = gevent.spawn(_queue_process) ds_green = gevent.spawn(_process_ds) try: gevent.joinall([ds_green, queue_green]) except KeyboardInterrupt: pass count_stats = dict( count_ds = ds_green.value, count_series = queue_green.value[0], count_errors = count_errors, count_success = count_success, count_modified = queue_green.value[1] ) msg = "modified[%(count_modified)s] - errors[%(count_errors)s] - success[%(count_success)s] - datasets[%(count_ds)s] - series[%(count_series)s]" logger.info(msg % count_stats)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import time import gevent from gevent import monkey monkey.patch_all() def create(n): print(n) time.sleep(0.5) while True: g1 = gevent.spawn(create, 1) g2 = gevent.spawn(create, 2) g3 = gevent.spawn(create, 3) g1.join() g2.join() g3.join()
def execute_without_std(self, command, wait=False): """Execute the given command in the sandbox using subprocess.Popen and discarding standard input, output and error. More specifically, the standard input gets closed just after the execution has started; standard output and error are read until the end, in a way that prevents the execution from being blocked because of insufficient buffering. command ([string]): executable filename and arguments of the command. return (bool): True if the sandbox didn't report errors (caused by the sandbox itself), False otherwise """ def preexec_fn(self): """Set limits for the child process. """ if self.chdir: os.chdir(self.chdir) # TODO - We're not checking that setrlimit() returns # successfully (they may try to set to higher limits than # allowed to); anyway, this is just for testing # environment, not for real contests, so who cares. if self.timeout: rlimit_cpu = self.timeout if self.extra_timeout: rlimit_cpu += self.extra_timeout rlimit_cpu = int(rlimit_cpu) + 1 resource.setrlimit(resource.RLIMIT_CPU, (rlimit_cpu, rlimit_cpu)) if self.address_space: rlimit_data = int(self.address_space * 1024) resource.setrlimit(resource.RLIMIT_DATA, (rlimit_data, rlimit_data)) if self.stack_space: rlimit_stack = int(self.stack_space * 1024) resource.setrlimit(resource.RLIMIT_STACK, (rlimit_stack, rlimit_stack)) # TODO - Doesn't work as expected #resource.setrlimit(resource.RLIMIT_NPROC, (1, 1)) # Setup std*** redirection if self.stdin_file: stdin_fd = os.open(os.path.join(self.path, self.stdin_file), os.O_RDONLY) else: stdin_fd = subprocess.PIPE if self.stdout_file: stdout_fd = os.open(os.path.join(self.path, self.stdout_file), os.O_WRONLY | os.O_TRUNC | os.O_CREAT, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR) else: stdout_fd = subprocess.PIPE if self.stderr_file: stderr_fd = os.open(os.path.join(self.path, self.stderr_file), os.O_WRONLY | os.O_TRUNC | os.O_CREAT, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR) else: stderr_fd = subprocess.PIPE # Note down execution time self.popen_time = monotonic_time() # Actually call the Popen self.popen = self._popen(command, stdin=stdin_fd, stdout=stdout_fd, stderr=stderr_fd, preexec_fn=partial(preexec_fn, self), close_fds=True) # Close file descriptors passed to the child if self.stdin_file: os.close(stdin_fd) if self.stdout_file: os.close(stdout_fd) if self.stderr_file: os.close(stderr_fd) if self.wallclock_timeout: # Kill the process after the wall clock time passed def timed_killer(timeout, popen): gevent.sleep(timeout) # TODO - Here we risk to kill some other process that gets # the same PID in the meantime; I don't know how to # properly solve this problem try: popen.kill() except OSError: # The process had died by itself pass # Setup the killer full_wallclock_timeout = self.wallclock_timeout if self.extra_timeout: full_wallclock_timeout += self.extra_timeout gevent.spawn(timed_killer, full_wallclock_timeout, self.popen) # If the caller wants us to wait for completion, we also avoid # std*** to interfere with command. Otherwise we let the # caller handle these issues. if wait: return self.translate_box_exitcode( wait_without_std([self.popen])[0]) else: return self.popen
def run(self): context = zmq.Context() receiver = context.socket(zmq.SUB) receiver.setsockopt(zmq.SUBSCRIBE, '') for binding in Settings.MONITOR_RECEIVER_BINDINGS: receiver.connect(binding) def monitor_worker(message): db = sqlite3.connect(Settings.MONITOR_DB) # Separate topic from message message = message.split(' |-| ') # Handle gateway not sending topic if len(message) > 1: message = message[1] else: message = message[0] if Settings.RELAY_DUPLICATE_MAX_MINUTES: if duplicateMessages.isDuplicated(message): schemaID = 'DUPLICATE MESSAGE' c = db.cursor() c.execute('UPDATE schemas SET hits = hits + 1 WHERE `name` = ? AND `dateStats` = DATE("now", "utc")', (schemaID, )) c.execute('INSERT OR IGNORE INTO schemas (name, dateStats) VALUES (?, DATE("now", "utc"))', (schemaID, )) db.commit() return if Settings.MONITOR_DECOMPRESS_MESSAGES: message = zlib.decompress(message) json = simplejson.loads(message) # Update software count softwareID = json['header']['softwareName'].encode('utf8') + ' | ' + json['header']['softwareVersion'].encode('utf8') c = db.cursor() c.execute('UPDATE softwares SET hits = hits + 1 WHERE `name` = ? AND `dateStats` = DATE("now", "utc")', (softwareID, )) c.execute('INSERT OR IGNORE INTO softwares (name, dateStats) VALUES (?, DATE("now", "utc"))', (softwareID, )) db.commit() # Update uploader count uploaderID = json['header']['uploaderID'].encode('utf8') if uploaderID: # Don't get empty uploaderID c = db.cursor() c.execute('UPDATE uploaders SET hits = hits + 1 WHERE `name` = ? AND `dateStats` = DATE("now", "utc")', (uploaderID, )) c.execute('INSERT OR IGNORE INTO uploaders (name, dateStats) VALUES (?, DATE("now", "utc"))', (uploaderID, )) db.commit() # Update schemas count schemaID = json['$schemaRef'] c = db.cursor() c.execute('UPDATE schemas SET hits = hits + 1 WHERE `name` = ? AND `dateStats` = DATE("now", "utc")', (schemaID, )) c.execute('INSERT OR IGNORE INTO schemas (name, dateStats) VALUES (?, DATE("now", "utc"))', (schemaID, )) db.commit() db.close() while True: inboundMessage = receiver.recv() gevent.spawn(monitor_worker, inboundMessage)
jobs = pd.read_csv( "./job.csv", encoding="gbk", header=None, names=["panel", "PID", "sample_N", "sample_T", "chip", "name"]) def check_list(df): if df["sample_T"] == "yaml无T": return df["sample_N"] else: return df["sample_T"] jobs["check_sample"] = jobs.apply(check_list, axis=1) def func(sample): print("start", sample) # subprocess.call("hand ags list|grep -i W067750T",shell=True) sub = subprocess.Popen(f"hand ags list|grep -i {sample}", shell=True) out, err = sub.communicate() job_list = [] for i in jobs["check_sample"]: job_list.append(gevent.spawn(func, i)) gevent.joinall(job_list)
def prep_task_queue(self): """prepare task_queue for another set of distributed tasks""" self._task_queue = JoinableQueue() spawn(self._consume_task_queue)
def main(): gevent.joinall( [gevent.spawn(setter), gevent.spawn(waiter), gevent.spawn(waiter)])
def async_func(): g_l = [] for i in range(10): g_l.append(gevent.spawn(task, i)) gevent.joinall(g_l)
def start(self): return gevent.spawn(self.serve_forever)
import gevent import gevent.wsgi import gevent.queue from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.wsgi import WsgiServerTransport from tinyrpc.server.gevent import RPCServerGreenlets from tinyrpc.dispatch import RPCDispatcher from threading import Lock dispatcher = RPCDispatcher() transport = WsgiServerTransport(max_content_length=4096 * 1024, queue_class=gevent.queue.Queue) # start wsgi server as a background-greenlet wsgi_server = gevent.wsgi.WSGIServer(('0.0.0.0', 10090), transport.handle) gevent.spawn(wsgi_server.serve_forever) rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher) TFPublisher = rospy.Publisher('tf', tfMessage, queue_size=1) rospy.init_node('UE_ROS_Bridge') tfBroadcaster = tf.TransformBroadcaster() serviceHandlers = {} messagePages = [{}, {}] messageSendingPage = [0] pageMutex = Lock() SetupListeners(pageMutex, messagePages, messageSendingPage) SetupServiceListeners(pageMutex, messagePages, messageSendingPage, serviceHandlers)
# -*-coding:utf-8-*- import gevent from gevent.queue import Queue q = Queue() def producer(name): print(f'producer({name}) is running') while not q.empty(): task = q.get() print(f'producer({name}) get task: {task}') gevent.sleep(1) def customer(): print(f'customer({gevent.getcurrent()}) is running') for i in range(10): q.put_nowait(i) if __name__ == '__main__': gevent.spawn(customer).join() gevent.joinall([ gevent.spawn(producer, 'a'), gevent.spawn(producer, 'b'), gevent.spawn(producer, 'c'), ])
def start(self): self.greenlet = gevent.spawn(self.start_server) self.greenlet.link_exception(greenlet_exception_handler)
def test(): tasks = [spawn(test_echo, proxy) for proxy in proxys] joinall(tasks)
def run_task(): # symbol = ['btc_usd','bch_usd','eth_usd','ltc_usd','eos_usd'] # contractType = ['this_week','next_week','quarter'] try: greenlets = [ gevent.spawn( future_kline_download("btc_usd", "this_week").download()), gevent.spawn( future_kline_download("bch_usd", "this_week").download()), gevent.spawn( future_kline_download("eth_usd", "this_week").download()), gevent.spawn( future_kline_download("ltc_usd", "this_week").download()), gevent.spawn( future_kline_download("eos_usd", "this_week").download()), gevent.spawn( future_kline_download("btc_usd", "next_week").download()), gevent.spawn( future_kline_download("bch_usd", "next_week").download()), gevent.spawn( future_kline_download("eth_usd", "next_week").download()), gevent.spawn( future_kline_download("ltc_usd", "next_week").download()), gevent.spawn( future_kline_download("eos_usd", "next_week").download()), gevent.spawn( future_kline_download("btc_usd", "quarter").download()), gevent.spawn( future_kline_download("bch_usd", "quarter").download()), gevent.spawn( future_kline_download("eth_usd", "quarter").download()), gevent.spawn( future_kline_download("ltc_usd", "quarter").download()), gevent.spawn( future_kline_download("eos_usd", "quarter").download()) ] gevent.joinall(greenlets) except Exception as e: print(e)
while True: gevent.sleep(1) now = time.time() elapsed = now - last req_sec = (i - last_i) / elapsed print('%s total requests (%.2f/sec). last log %.2f sec ago.' % (i, req_sec, elapsed)) last_i = i last = now class Server(LoquiServer): def handle_request(self, request, session): global i i += 1 if i and i % 50000 == 0: session.close() return 'm' * 1024 def handle_push(self, push, session): print('pushed', push.data) return if __name__ == '__main__': s = Server(('localhost', 8080)) gevent.spawn(log_loop) s.serve_forever()
#-*- coding:utf-8 -*- from gevent import monkey monkey.patch_all() import gevent import requests def get_page(url): print("GET:%s" % url) response = requests.get(url) print(url, len(response.text)) return len(response.text) g1 = gevent.spawn(get_page, 'https://www.python.org/doc') g2 = gevent.spawn(get_page, 'http://www.163.com') g3 = gevent.spawn(get_page, 'https://www.openstack.org') gevent.joinall([ g1, g2, g3, ]) print(g1.value, g2.value, g3.value) #拿到返回值 #协程池 # from gevent.pool import Pool # pool=Pool(2) # g1=pool.spawn(get_page,'https://www.python.org/doc') # g2=pool.spawn(get_page,'http://www.163.com') # g3=pool.spawn(get_page,'https://www.openstack.org')
def process_gym(self, gym): gym_id = gym['id'] # Update Gym details (if they exist) if gym_id not in self.__gym_info or gym['name'] != 'unknown': self.__gym_info[gym_id] = { "name": gym['name'], "description": gym['description'], "url": gym['url'] } if self.__gym_settings['enabled'] is False: log.debug("Gym ignored: notifications are disabled.") return # Extract some basic information to_team_id = gym['new_team_id'] from_team_id = self.__gym_hist.get(gym_id) # Doesn't look like anything to me if to_team_id == from_team_id: log.debug("Gym ignored: no change detected") return # Ignore changes to neutral if self.__gym_settings['ignore_neutral'] and to_team_id == 0: log.debug("Gym update ignored: changed to neutral") return # Update gym's last known team self.__gym_hist[gym_id] = to_team_id # Ignore first time updates if from_team_id is None: log.debug("Gym update ignored: first time seeing this gym") return # Get some more info out used to check filters lat, lng = gym['lat'], gym['lng'] dist = get_earth_dist([lat, lng], self.__location) cur_team = self.__locale.get_team_name(to_team_id) old_team = self.__locale.get_team_name(from_team_id) filters = self.__gym_settings['filters'] passed = False for filt_ct in range(len(filters)): filt = filters[filt_ct] # Check the distance from the set location if dist != 'unkn': if filt.check_dist(dist) is False: if self.__quiet is False: log.info( "Gym rejected: distance ({:.2f}) was not in range" + " {:.2f} to {:.2f} (F #{})".format( dist, filt.min_dist, filt.max_dist, filt_ct)) continue else: log.debug( "Gym dist was not checked because the manager has no location set." ) # Check the old team if filt.check_from_team(from_team_id) is False: if self.__quiet is False: log.info( "Gym rejected: {} as old team is not correct (F #{})". format(old_team, filt_ct)) continue # Check the new team if filt.check_to_team(to_team_id) is False: if self.__quiet is False: log.info( "Gym rejected: {} as current team is not correct (F #{})" .format(cur_team, filt_ct)) continue # Nothing left to check, so it must have passed passed = True log.debug("Gym passed filter #{}".format(filt_ct)) break if not passed: return # Check the geofences gym['geofence'] = self.check_geofences('Gym', lat, lng) if len(self.__geofences) > 0 and gym['geofence'] == 'unknown': log.info("Gym rejected: not inside geofence(s)") return # Check if in geofences if len(self.__geofences) > 0: inside = False for gf in self.__geofences: inside |= gf.contains(lat, lng) if inside is False: if self.__quiet is False: log.info("Gym update ignored: located outside geofences.") return else: log.debug( "Gym inside geofences was not checked because no geofences were set." ) gym_info = self.__gym_info.get(gym_id, {}) gym.update({ "gym_name": gym_info.get('name', 'unknown'), "gym_description": gym_info.get('description', 'unknown'), "gym_url": gym_info.get( 'url', 'https://raw.githubusercontent.com/RocketMap/PokeAlarm/master/icons/gym_0.png' ), "dist": get_dist_as_str(dist), 'dir': get_cardinal_dir([lat, lng], self.__location), 'new_team': cur_team, 'new_team_id': to_team_id, 'old_team': old_team, 'old_team_id': from_team_id, 'new_team_leader': self.__locale.get_leader_name(to_team_id), 'old_team_leader': self.__locale.get_leader_name(from_team_id) }) if self.__loc_service: self.__loc_service.add_optional_arguments(self.__location, [lat, lng], gym) if self.__quiet is False: log.info( "Gym ({}) notification has been triggered!".format(gym_id)) threads = [] # Spawn notifications in threads so they can work in background for alarm in self.__alarms: threads.append(gevent.spawn(alarm.gym_alert, gym)) gevent.sleep(0) # explict context yield for thread in threads: thread.join()
def handle_one_response(self): path = self.environ.get('PATH_INFO') # Kick non-socket.io requests to our superclass if not path.lstrip('/').startswith(self.server.resource): return super(SocketIOHandler, self).handle_one_response() self.status = None self.headers_sent = False self.result = None self.response_length = 0 self.response_use_chunked = False request_method = self.environ.get("REQUEST_METHOD") request_tokens = self.RE_REQUEST_URL.match(path) # Parse request URL and QUERY_STRING and do handshake if request_tokens: request_tokens = request_tokens.groupdict() else: handshake_tokens = self.RE_HANDSHAKE_URL.match(path) if handshake_tokens: return self._do_handshake(handshake_tokens.groupdict()) else: # This is no socket.io request. Let the WSGI app handle it. return super(SocketIOHandler, self).handle_one_response() # Setup the transport and socket transport = self.handler_types.get(request_tokens["transport_id"]) sessid = request_tokens["sessid"] socket = self.server.get_socket(sessid) # In case this is WebSocket request, switch to the WebSocketHandler # FIXME: fix this ugly class change if issubclass( transport, (transports.WebsocketTransport, transports.FlashSocketTransport)): self.__class__ = WebSocketHandler self.prevent_wsgi_call = True # thank you # TODO: any errors, treat them ?? self.handle_one_response() # Make the socket object available for WSGI apps self.environ['socketio'] = socket # Create a transport and handle the request likewise self.transport = transport(self) jobs = self.transport.connect(socket, request_method) # Keep track of those jobs (reading, writing and heartbeat jobs) so # that we can kill them later with Socket.kill() socket.jobs.extend(jobs) try: # We'll run the WSGI app if it wasn't already done. if socket.wsgi_app_greenlet is None: # TODO: why don't we spawn a call to handle_one_response here ? # why call directly the WSGI machinery ? start_response = lambda status, headers, exc=None: None socket.wsgi_app_greenlet = gevent.spawn( self.application, self.environ, start_response) except: self.handle_error(*sys.exc_info()) # TODO DOUBLE-CHECK: do we need to joinall here ? gevent.joinall(jobs)