def Worker(sock, addr): write_channel = stackless.channel() write_channel.preference = 1 # Prefer the sender. now_ts = time.time() timestamps = [now_ts, now_ts] # read_ts, write_ts writer_tasklet = stackless.tasklet(Writer)(timestamps, write_channel, sock) sleeper_tasklet = stackless.tasklet(Sleeper)(timestamps, write_channel, 3) # TODO(pts): Flush earlier. write_channel.send('Hello, please type something.\r\n') try: while True: msg = sock.recv(256) if not msg: break timestamps[0] = max(timestamps[0], time.time()) # Register read. # TODO(pts): Flush earlier. write_channel.send('You typed %r.\r\n' % msg) finally: logging.info('connection closed from %r' % (addr, )) if writer_tasklet.alive: write_channel.send(None) # Will kill writer_tasklet eventually. timestamps[0] = None # Will kill sleeper_tasklet eventually. while writer_tasklet.alive or sleeper_tasklet.alive: stackless.schedule(None) sock.close()
def Worker(sock, addr): write_channel = stackless.channel() write_channel.preference = 1 # Prefer the sender. now_ts = time.time() timestamps = [now_ts, now_ts] # read_ts, write_ts writer_tasklet = stackless.tasklet(Writer)(timestamps, write_channel, sock) sleeper_tasklet = stackless.tasklet(Sleeper)(timestamps, write_channel, 3) # TODO(pts): Flush earlier. write_channel.send('Hello, please type something.\r\n') try: while True: msg = sock.recv(256) if not msg: break timestamps[0] = max(timestamps[0], time.time()) # Register read. # TODO(pts): Flush earlier. write_channel.send('You typed %r.\r\n' % msg) finally: logging.info('connection closed from %r' % (addr,)) if writer_tasklet.alive: write_channel.send(None) # Will kill writer_tasklet eventually. timestamps[0] = None # Will kill sleeper_tasklet eventually. while writer_tasklet.alive or sleeper_tasklet.alive: stackless.schedule(None) sock.close()
def main(): # Without patch.patch_socket() or patch.patch_pymysql() the # counter below would jump from 0 to 1000 in one big step. With this # patch, MySQL socket communication is done with Syncless, so the counter # increases in little steps. patch.patch_pymysql() # patch_socket() works instead of patch_pymysql(), but it effects more # Python modules. #patch.patch_socket() patch.patch_stderr() mysql_config = dict(MYSQL_CONFIG) if 'password' in mysql_config: mysql_config['passwd'] = mysql_config.pop('password') if 'database' in mysql_config: mysql_config['db'] = mysql_config.pop('database') if mysql_config.get('unix_socket'): mysql_config['host'] = '127.0.0.1' #mysql_config['charset'] = 'utf8' db_conn = mysql_dbapi.connect(**mysql_config) assert mysql_dbapi.paramstyle == 'format' cursor = db_conn.cursor() cursor.execute('SET NAMES %s COLLATE %s', ('utf8', 'utf8_general_ci')) cursor = db_conn.cursor() # In SQLite, this would be: # for row in cursor.execute('SELECT LENGTH(?), ('\xC3\xA1',)): print row cursor.execute('SELECT CHAR_LENGTH(%s)', ('\xC3\xA1', )) #for row in cursor: # Fetch results. # print >>sys.stderr, row assert list(cursor) == [(1, )] if len(sys.argv) > 1: num_iterations = int(sys.argv) else: num_iterations = 1000 progress_channel = stackless.channel() progress_channel.preference = 1 # Prefer the sender. stackless.tasklet(Worker)(db_conn, num_iterations, progress_channel) done_count = 0 receive_count = 0 while True: sys.stderr.write('\r%s of %s ' % (done_count, num_iterations)) if done_count >= num_iterations: break done_count = progress_channel.receive() receive_count += 1 # receive_count might be smaller than done_count (e.g. 993 < 1000) here # (but sometims it's equal), because sometimes the main tasklet was slow # to receive, so Worker did multiple iterations per one # progress_channel.receive(). sys.stderr.write('done, receive_count=%d\n' % receive_count) # Needed for exit because we might have done DNS lookups with coio (evdns). stackless.main.insert() sys.exit(0)
def main(): # Without patch.patch_socket() or patch.patch_pymysql() the # counter below would jump from 0 to 1000 in one big step. With this # patch, MySQL socket communication is done with Syncless, so the counter # increases in little steps. patch.patch_pymysql() # patch_socket() works instead of patch_pymysql(), but it effects more # Python modules. # patch.patch_socket() patch.patch_stderr() mysql_config = dict(MYSQL_CONFIG) if "password" in mysql_config: mysql_config["passwd"] = mysql_config.pop("password") if "database" in mysql_config: mysql_config["db"] = mysql_config.pop("database") if mysql_config.get("unix_socket"): mysql_config["host"] = "127.0.0.1" # mysql_config['charset'] = 'utf8' db_conn = mysql_dbapi.connect(**mysql_config) assert mysql_dbapi.paramstyle == "format" cursor = db_conn.cursor() cursor.execute("SET NAMES %s COLLATE %s", ("utf8", "utf8_general_ci")) cursor = db_conn.cursor() # In SQLite, this would be: # for row in cursor.execute('SELECT LENGTH(?), ('\xC3\xA1',)): print row cursor.execute("SELECT CHAR_LENGTH(%s)", ("\xC3\xA1",)) # for row in cursor: # Fetch results. # print >>sys.stderr, row assert list(cursor) == [(1,)] if len(sys.argv) > 1: num_iterations = int(sys.argv) else: num_iterations = 1000 progress_channel = stackless.channel() progress_channel.preference = 1 # Prefer the sender. stackless.tasklet(Worker)(db_conn, num_iterations, progress_channel) done_count = 0 receive_count = 0 while True: sys.stderr.write("\r%s of %s " % (done_count, num_iterations)) if done_count >= num_iterations: break done_count = progress_channel.receive() receive_count += 1 # receive_count might be smaller than done_count (e.g. 993 < 1000) here # (but sometims it's equal), because sometimes the main tasklet was slow # to receive, so Worker did multiple iterations per one # progress_channel.receive(). sys.stderr.write("done, receive_count=%d\n" % receive_count) # Needed for exit because we might have done DNS lookups with coio (evdns). stackless.main.insert() sys.exit(0)
def main(): # Without patch.patch_socket() or patch.patch_mysql_connector() the # counter below would jump from 0 to 1000 in one big step. With this # patch, MySQL socket communication is done with Syncless, so the counter # increases in little steps. patch.patch_mysql_connector() # patch_socket() works instead of patch_mysql_connector(), but it effects more # Python modules. #patch.patch_socket() patch.patch_stderr() db_conn = mysql_dbapi.connect(**MYSQL_CONFIG) assert mysql_dbapi.paramstyle == 'pyformat' assert db_conn.charset_name == 'utf8' assert db_conn.collation_name == 'utf8_general_ci' #query = 'SELECT CONNECTION_ID()' #query = 'SELECT LENGTH("\xC3\xA1")' # :2 #query = 'SELECT CHAR_LENGTH("\xC3\xA1")' #: 1 #query = 'SELECT UPPER("\xC3\xA1")' #: '\xC3\x81' # Would raise e.g. mysql.connector.errors.ProgrammingError on SQL error. cursor = db_conn.cursor() # In SQLite, this would be: # for row in cursor.execute('SELECT LENGTH(?), ('\xC3\xA1',)): print row cursor.execute('SELECT CHAR_LENGTH(%s)', ('\xC3\xA1',)) #for row in cursor: # Fetch results. # print >>sys.stderr, row assert list(cursor) == [(1,)] if len(sys.argv) > 1: num_iterations = int(sys.argv) else: num_iterations = 1000 progress_channel = stackless.channel() progress_channel.preference = 1 # Prefer the sender. stackless.tasklet(Worker)(db_conn, num_iterations, progress_channel) done_count = 0 receive_count = 0 while True: sys.stderr.write('\r%s of %s ' % (done_count, num_iterations)) if done_count >= num_iterations: break done_count = progress_channel.receive() receive_count += 1 # receive_count might be smaller than done_count (e.g. 993 < 1000) here # (but sometims it's equal), because sometimes the main tasklet was slow # to receive, so Worker did multiple iterations per one # progress_channel.receive(). sys.stderr.write('done, receive_count=%d\n' % receive_count) # Needed for exit because we might have done DNS lookups with coio (evdns). stackless.main.insert() sys.exit(0)
def main(): # Without patch.patch_socket() or patch.patch_mysql_connector() the # counter below would jump from 0 to 1000 in one big step. With this # patch, MySQL socket communication is done with Syncless, so the counter # increases in little steps. patch.patch_mysql_connector() # patch_socket() works instead of patch_mysql_connector(), but it effects more # Python modules. #patch.patch_socket() patch.patch_stderr() db_conn = mysql_dbapi.connect(**MYSQL_CONFIG) assert mysql_dbapi.paramstyle == 'pyformat' assert db_conn.charset_name == 'utf8' assert db_conn.collation_name == 'utf8_general_ci' #query = 'SELECT CONNECTION_ID()' #query = 'SELECT LENGTH("\xC3\xA1")' # :2 #query = 'SELECT CHAR_LENGTH("\xC3\xA1")' #: 1 #query = 'SELECT UPPER("\xC3\xA1")' #: '\xC3\x81' # Would raise e.g. mysql.connector.errors.ProgrammingError on SQL error. cursor = db_conn.cursor() # In SQLite, this would be: # for row in cursor.execute('SELECT LENGTH(?), ('\xC3\xA1',)): print row cursor.execute('SELECT CHAR_LENGTH(%s)', ('\xC3\xA1', )) #for row in cursor: # Fetch results. # print >>sys.stderr, row assert list(cursor) == [(1, )] if len(sys.argv) > 1: num_iterations = int(sys.argv) else: num_iterations = 1000 progress_channel = stackless.channel() progress_channel.preference = 1 # Prefer the sender. stackless.tasklet(Worker)(db_conn, num_iterations, progress_channel) done_count = 0 receive_count = 0 while True: sys.stderr.write('\r%s of %s ' % (done_count, num_iterations)) if done_count >= num_iterations: break done_count = progress_channel.receive() receive_count += 1 # receive_count might be smaller than done_count (e.g. 993 < 1000) here # (but sometims it's equal), because sometimes the main tasklet was slow # to receive, so Worker did multiple iterations per one # progress_channel.receive(). sys.stderr.write('done, receive_count=%d\n' % receive_count) # Needed for exit because we might have done DNS lookups with coio (evdns). stackless.main.insert() sys.exit(0)
def main(): patch.patch_socket() patch.patch_ssl() result_channel = stackless.channel() result_channel.preference = 1 # Prefer the sender. stackless.tasklet(FetchWorker)('https://www.facebook.com/', result_channel) progress_reporter_tasklet = stackless.tasklet(ProgressReporter)(0.02) # This blocks the current tasklet, while FetchWorker and ProgressReporter are # running. data = result_channel.receive() progress_reporter_tasklet.kill() sys.stderr.write("\n") match = re.search(r'(?is)<title>(.*?)</title>', data) if match: data = match.group(1).strip() print 'Downloaded:', data # Needed for exit because we did DNS lookups with coio (evdns). # TODO(pts): Remove stackless.main.insert() once the segfault bug is fixed. stackless.main.insert() sys.exit(0)
def main(): # Without patch.geventmysql() run by importing fast_mysql, not only the # counter below would jump from 0 to 1000 in one big step, but maybe the # client wouldn't work at all, because vanilla gevenymysql expects gevent, # but we use Syncless here. With this patch, MySQL socket communication is # done with Syncless, so the counter increases in little steps. patch.patch_stderr() # Preprocess the connection information. mysql_config = dict(MYSQL_CONFIG) if mysql_config.get('unix_socket'): mysql_config['host'] = mysql_config.pop('unix_socket') mysql_config['port'] = None assert mysql_config['host'].startswith('/') if 'database' in mysql_config: mysql_config['db'] = mysql_config.pop('database') old_use_unicode = bool(mysql_config.pop('use_unicode', False)) mysql_config['use_unicode'] = True # Required for mysql_config['charset']. mysql_config.setdefault('charset', 'utf-8') db_conn = geventmysql.connect(**mysql_config) db_conn.client.set_use_unicode(old_use_unicode) assert geventmysql.paramstyle == 'format' # These are not supported by geventmysql. #assert db_conn.charset_name == 'utf8' #assert db_conn.collation_name == 'utf8_general_ci' #query = 'SELECT CONNECTION_ID()' #query = 'SELECT LENGTH("\xC3\xA1")' # :2 #query = 'SELECT CHAR_LENGTH("\xC3\xA1")' #: 1 #query = 'SELECT UPPER("\xC3\xA1")' #: '\xC3\x81' # Would raise e.g. mysql.connector.errors.ProgrammingError on SQL error. cursor = db_conn.cursor() # In SQLite, this would be: # for row in cursor.execute('SELECT LENGTH(?), ('\xC3\xA1',)): print row cursor.execute('SELECT CHAR_LENGTH(%s)', ('\xC3\xA1',)) # Since geventmysql cursors are not iterable, we have to use # cursor.fetchall() instead of list(cursor) here. assert cursor.fetchall() == [(1,)] cursor.close() # geventmysql requires this. if len(sys.argv) > 1: num_iterations = int(sys.argv) else: num_iterations = 1000 progress_channel = stackless.channel() progress_channel.preference = 1 # Prefer the sender. stackless.tasklet(Worker)(db_conn, num_iterations, progress_channel) done_count = 0 receive_count = 0 while True: sys.stderr.write('\r%s of %s ' % (done_count, num_iterations)) if done_count >= num_iterations: break done_count = progress_channel.receive() receive_count += 1 # receive_count might be smaller than done_count (e.g. 993 < 1000) here # (but sometims it's equal), because sometimes the main tasklet was slow # to receive, so Worker did multiple iterations per one # progress_channel.receive(). sys.stderr.write('done, receive_count=%d\n' % receive_count) # Needed for exit because we might have done DNS lookups with coio (evdns). stackless.main.insert() sys.exit(0)
def __init__(self, items=(), preference=1): self.deque = deque(items) self.channel = stackless.channel() self.channel.preference = preference # preference=1: prefer the sender.
def main(): # Without patch.geventmysql() run by importing fast_mysql, not only the # counter below would jump from 0 to 1000 in one big step, but maybe the # client wouldn't work at all, because vanilla gevenymysql expects gevent, # but we use Syncless here. With this patch, MySQL socket communication is # done with Syncless, so the counter increases in little steps. patch.patch_stderr() # Preprocess the connection information. mysql_config = dict(MYSQL_CONFIG) if mysql_config.get('unix_socket'): mysql_config['host'] = mysql_config.pop('unix_socket') mysql_config['port'] = None assert mysql_config['host'].startswith('/') if 'database' in mysql_config: mysql_config['db'] = mysql_config.pop('database') old_use_unicode = bool(mysql_config.pop('use_unicode', False)) mysql_config['use_unicode'] = True # Required for mysql_config['charset']. mysql_config.setdefault('charset', 'utf-8') db_conn = geventmysql.connect(**mysql_config) db_conn.client.set_use_unicode(old_use_unicode) assert geventmysql.paramstyle == 'format' # These are not supported by geventmysql. #assert db_conn.charset_name == 'utf8' #assert db_conn.collation_name == 'utf8_general_ci' #query = 'SELECT CONNECTION_ID()' #query = 'SELECT LENGTH("\xC3\xA1")' # :2 #query = 'SELECT CHAR_LENGTH("\xC3\xA1")' #: 1 #query = 'SELECT UPPER("\xC3\xA1")' #: '\xC3\x81' # Would raise e.g. mysql.connector.errors.ProgrammingError on SQL error. cursor = db_conn.cursor() # In SQLite, this would be: # for row in cursor.execute('SELECT LENGTH(?), ('\xC3\xA1',)): print row cursor.execute('SELECT CHAR_LENGTH(%s)', ('\xC3\xA1', )) # Since geventmysql cursors are not iterable, we have to use # cursor.fetchall() instead of list(cursor) here. assert cursor.fetchall() == [(1, )] cursor.close() # geventmysql requires this. if len(sys.argv) > 1: num_iterations = int(sys.argv) else: num_iterations = 1000 progress_channel = stackless.channel() progress_channel.preference = 1 # Prefer the sender. stackless.tasklet(Worker)(db_conn, num_iterations, progress_channel) done_count = 0 receive_count = 0 while True: sys.stderr.write('\r%s of %s ' % (done_count, num_iterations)) if done_count >= num_iterations: break done_count = progress_channel.receive() receive_count += 1 # receive_count might be smaller than done_count (e.g. 993 < 1000) here # (but sometims it's equal), because sometimes the main tasklet was slow # to receive, so Worker did multiple iterations per one # progress_channel.receive(). sys.stderr.write('done, receive_count=%d\n' % receive_count) # Needed for exit because we might have done DNS lookups with coio (evdns). stackless.main.insert() sys.exit(0)