Eventlet/Examples - Revision history

Chaser Zaks at 15:40, 27 June 2017

2017-06-27T15:40:23Z

← Older revision		Revision as of 08:40, 27 June 2017
Line 7:		Line 7:
	This is a simple server that listens on port 6000 and simply echoes back every input line it receives. Connect to it with: <code>telnet localhost 6000</code> Terminate your connection by quitting telnet (typically Ctrl-] and then 'quit')		This is a simple server that listens on port 6000 and simply echoes back every input line it receives. Connect to it with: <code>telnet localhost 6000</code> Terminate your connection by quitting telnet (typically Ctrl-] and then 'quit')

	<python>from eventlet import api		<syntaxhighlight lang="python">from eventlet import api

	def handle_socket(client):		def handle_socket(client):
Line 27:		Line 27:
	api.spawn(handle_socket, new_sock)		api.spawn(handle_socket, new_sock)

	server.close()</~~python~~>		server.close()</syntaxhighlight>

	== web crawler ==		== web crawler ==
Line 33:		Line 33:
	This is a simple web "crawler" that fetches a bunch of urls using a coroutine pool. It has as much concurrency (i.e. pages being fetched simultaneously) as coroutines in the pool.		This is a simple web "crawler" that fetches a bunch of urls using a coroutine pool. It has as much concurrency (i.e. pages being fetched simultaneously) as coroutines in the pool.

	<python>urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",		<syntaxhighlight lang="python">urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",
	"http://wiki.secondlife.com/w/images/secondlife.jpg",		"http://wiki.secondlife.com/w/images/secondlife.jpg",
	"http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]		"http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]
Line 59:		Line 59:
	# wait for all the coroutines to come back before exiting the process		# wait for all the coroutines to come back before exiting the process
	for waiter in waiters:		for waiter in waiters:
	waiter.wait()</~~python~~>		waiter.wait()</syntaxhighlight>

Which Linden: /* echo server */ Fix to match hg eventlet, b/c that doesn't have filelike sockets.

2008-08-15T22:56:08Z

echo server: Fix to match hg eventlet, b/c that doesn't have filelike sockets.

← Older revision		Revision as of 15:56, 15 August 2008
Line 11:		Line 11:
	def handle_socket(client):		def handle_socket(client):
	print "client connected"		print "client connected"
			fp = client.makefile()
	while True:		while True:
	# pass through every non-eof line		# pass through every non-eof line
	x = ~~client~~.readline()		x = fp.readline()
	if not x: break		if not x: break
	~~client~~.write(x)		fp.write(x)
	print "echoed", x		print "echoed", x
	print "client disconnected"		print "client disconnected"

Which Linden: Wewt python syntax highlighting ftw.

2008-01-03T23:58:10Z

Wewt python syntax highlighting ftw.

← Older revision		Revision as of 16:58, 3 January 2008
Line 7:		Line 7:
	This is a simple server that listens on port 6000 and simply echoes back every input line it receives. Connect to it with: <code>telnet localhost 6000</code> Terminate your connection by quitting telnet (typically Ctrl-] and then 'quit')		This is a simple server that listens on port 6000 and simply echoes back every input line it receives. Connect to it with: <code>telnet localhost 6000</code> Terminate your connection by quitting telnet (typically Ctrl-] and then 'quit')

	from eventlet import api		<python>from eventlet import api

	def handle_socket(client):		def handle_socket(client):
	print "client connected"		print "client connected"
	while True:		while True:
	# pass through every non-eof line		# pass through every non-eof line
	x = client.readline()		x = client.readline()
	if not x: break		if not x: break
	client.write(x)		client.write(x)
	print "echoed", x		print "echoed", x
	print "client disconnected"		print "client disconnected"

	# server socket listening on port 6000		# server socket listening on port 6000
	server = api.tcp_listener(('0.0.0.0', 6000))		server = api.tcp_listener(('0.0.0.0', 6000))
	while True:		while True:
	new_sock, address = server.accept()		new_sock, address = server.accept()
	# handle every new connection with a new coroutine		# handle every new connection with a new coroutine
	api.spawn(handle_socket, new_sock)		api.spawn(handle_socket, new_sock)

	server.close()		server.close()</python>

	== web crawler ==		== web crawler ==
Line 32:		Line 32:
	This is a simple web "crawler" that fetches a bunch of urls using a coroutine pool. It has as much concurrency (i.e. pages being fetched simultaneously) as coroutines in the pool.		This is a simple web "crawler" that fetches a bunch of urls using a coroutine pool. It has as much concurrency (i.e. pages being fetched simultaneously) as coroutines in the pool.

	urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",		<python>urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",
	"http://wiki.secondlife.com/w/images/secondlife.jpg",		"http://wiki.secondlife.com/w/images/secondlife.jpg",
	"http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]		"http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]

			import time
			from eventlet import coros, httpc, util

	~~import time~~		# replace socket with a cooperative coroutine socket because httpc
	~~from eventlet import coros, httpc, util~~		# uses httplib, which uses socket. Removing this serializes the http
			# requests, because the standard socket is blocking.
	# replace socket with a cooperative coroutine socket because httpc		util.wrap_socket_with_coroutine_socket()
	# uses httplib, which uses socket. Removing this serializes the http
	# requests, because the standard socket is blocking.		def fetch(url):
	util.wrap_socket_with_coroutine_socket()		# we could do something interesting with the result, but this is
			# example code, so we'll just report that we did it
	def fetch(url):		print "%s fetching %s" % (time.asctime(), url)
	# we could do something interesting with the result, but this is		httpc.get(url)
	# example code, so we'll just report that we did it		print "%s fetched %s" % (time.asctime(), url)
	print "%s fetching %s" % (time.asctime(), url)
	httpc.get(url)		pool = coros.CoroutinePool(max_size=4)
	print "%s fetched %s" % (time.asctime(), url)		waiters = []
			for url in urls:
	pool = coros.CoroutinePool(max_size=4)		waiters.append(pool.execute(fetch, url))
	waiters = []
	for url in urls:		# wait for all the coroutines to come back before exiting the process
	waiters.append(pool.execute(fetch, url))		for waiter in waiters:
			waiter.wait()</python>
	# wait for all the coroutines to come back before exiting the process
	for waiter in waiters:
	waiter.wait()

Which Linden: /* web crawler */ reword a bit

2007-08-24T22:33:17Z

web crawler: reword a bit

← Older revision		Revision as of 15:33, 24 August 2007
Line 30:		Line 30:
	== web crawler ==		== web crawler ==

	This is a simple web "crawler" that fetches a bunch of urls using a coroutine pool. It ~~fetches~~ as ~~many urls at time~~ as coroutines in the pool.		This is a simple web "crawler" that fetches a bunch of urls using a coroutine pool. It has as much concurrency (i.e. pages being fetched simultaneously) as coroutines in the pool.

	urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",		urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",

Which Linden: /* echo server */ fixed weird formatting

2007-08-24T22:32:56Z

echo server: fixed weird formatting

← Older revision		Revision as of 15:32, 24 August 2007
Line 5:		Line 5:
	== echo server ==		== echo server ==

	This is a simple server that listens on port 6000 and simply echoes back every input line it receives. Connect to it with:		This is a simple server that listens on port 6000 and simply echoes back every input line it receives. Connect to it with: <code>telnet localhost 6000</code> Terminate your connection by quitting telnet (typically Ctrl-] and then 'quit')
	telnet localhost 6000 ~~You terminate~~ your connection by ~~terminating~~ telnet (typically Ctrl-] and then 'quit')

	from eventlet import api		from eventlet import api

Which Linden: New page: = Examples = These are short examples demonstrating the use of Eventlet. They are also included in the `examples` directory of the source. == echo server == This is a si...

2007-08-24T22:29:40Z

New page: = Examples = These are short examples demonstrating the use of Eventlet. They are also included in the <code>examples</code> directory of the source. == echo server == This is a si...

New page

= Examples =

These are short examples demonstrating the use of [[Eventlet]]. They are also included in the <code>examples</code> directory of the source.

== echo server ==

This is a simple server that listens on port 6000 and simply echoes back every input line it receives. Connect to it with:
telnet localhost 6000 You terminate your connection by terminating telnet (typically Ctrl-] and then 'quit')

from eventlet import api

def handle_socket(client):
print "client connected"
while True:
# pass through every non-eof line
x = client.readline()
if not x: break
client.write(x)
print "echoed", x
print "client disconnected"

# server socket listening on port 6000
server = api.tcp_listener(('0.0.0.0', 6000))
while True:
new_sock, address = server.accept()
# handle every new connection with a new coroutine
api.spawn(handle_socket, new_sock)

server.close()

== web crawler ==

This is a simple web "crawler" that fetches a bunch of urls using a coroutine pool. It fetches as many urls at time as coroutines in the pool.

urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",
"http://wiki.secondlife.com/w/images/secondlife.jpg",
"http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]

import time
from eventlet import coros, httpc, util

# replace socket with a cooperative coroutine socket because httpc
# uses httplib, which uses socket. Removing this serializes the http
# requests, because the standard socket is blocking.
util.wrap_socket_with_coroutine_socket()

def fetch(url):
# we could do something interesting with the result, but this is
# example code, so we'll just report that we did it
print "%s fetching %s" % (time.asctime(), url)
httpc.get(url)
print "%s fetched %s" % (time.asctime(), url)

pool = coros.CoroutinePool(max_size=4)
waiters = []
for url in urls:
waiters.append(pool.execute(fetch, url))

# wait for all the coroutines to come back before exiting the process
for waiter in waiters:
waiter.wait()