def test_timeout_cancel(self):
server = api.tcp_listener(('0.0.0.0', 0))
bound_port = server.getsockname()[1]
def client_connected(server):
(conn, addr) = server
conn.close()
def go():
client = util.tcp_socket()
desc = greenio.GreenSocket(client)
desc.connect(('127.0.0.1', bound_port))
try:
api.trampoline(desc, read=True, write=True, timeout=0.1)
except api.TimeoutError:
assert False, "Timed out"
server.close()
client.close()
api.call_after(0, go)
api.tcp_server(server, client_connected)
check_hub()
def setUp(self):
self.logfile = StringIO()
self.victim = api.spawn(wsgi.server,
api.tcp_listener(('0.0.0.0', 31337)),
self.site_class(),
log=self.logfile,
max_size=128)
def test_del_closes_socket(self):
timer = api.exc_after(0.5, api.TimeoutError)
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.makeGreenFile()
conn.write('hello\n')
conn.close()
self.assertRaises(socket.error, conn.write, 'a')
finally:
listener.close()
server = api.tcp_listener(('0.0.0.0', 0))
killer = api.spawn(accept_once, server)
client = api.connect_tcp(('127.0.0.1', server.getsockname()[1]))
fd = client.makeGreenFile()
client.close()
assert fd.read() == b'hello\n'
assert fd.read() == ''
timer.cancel()
def test_close_with_makefile(self):
def accept_close_early(listener):
# verify that the makefile and the socket are truly independent
# by closing the socket prior to using the made file
try:
conn, addr = listener.accept()
fd = conn.makeGreenFile()
conn.close()
fd.write('hello\n')
fd.close()
self.assertRaises(socket.error, fd.write, 'a')
self.assertRaises(socket.error, conn.send, 'b')
finally:
listener.close()
def accept_close_late(listener):
# verify that the makefile and the socket are truly independent
# by closing the made file and then sending a character
try:
conn, addr = listener.accept()
fd = conn.makeGreenFile()
fd.write('hello')
fd.close()
conn.send('\n')
conn.close()
self.assertRaises(socket.error, fd.write, 'a')
self.assertRaises(socket.error, conn.send, 'b')
finally:
listener.close()
def did_it_work(server):
client = api.connect_tcp(('127.0.0.1', server.getsockname()[1]))
fd = client.makeGreenFile()
client.close()
assert fd.readline() == b'hello\n'
assert fd.read() == ''
fd.close()
server = api.tcp_listener(('0.0.0.0', 0))
killer = api.spawn(accept_close_early, server)
did_it_work(server)
api.kill(killer)
server = api.tcp_listener(('0.0.0.0', 0))
killer = api.spawn(accept_close_late, server)
did_it_work(server)
api.kill(killer)
def setUp(self):
self.logfile = StringIO()
self.site = Site()
self.killer = api.spawn(wsgi.server,
api.tcp_listener(('0.0.0.0', 12346)),
self.site,
max_size=128,
log=self.logfile)
def test_001_trampoline_timeout(self):
server = api.tcp_listener(('0.0.0.0', 0))
bound_port = server.getsockname()[1]
try:
desc = greenio.GreenSocket(util.tcp_socket())
desc.connect(('127.0.0.1', bound_port))
api.trampoline(desc, read=True, write=False, timeout=0.1)
except api.TimeoutError:
pass # test passed
else:
assert False, "Didn't timeout"
check_hub()
def test_ssl_proxy_redirects(self):
# make sure that if the proxy returns a redirect, that httpc
# successfully follows it (this was broken at one point)
def ssl_proxy(sock):
conn, addr = sock.accept()
fd = conn.makefile()
try:
line = request = fd.readline()
self.assertEqual(request,
'GET https://localhost:1234 HTTP/1.1\r\n')
while line.strip(): # eat request headers
line = fd.readline()
# we're not going to actually proxy to localhost:1234,
# we're just going to return a response on its behalf
fd.write(
"HTTP/1.0 302 Found\r\nLocation: https://localhost:1234/2\r\n\r\n"
)
finally:
fd.close()
conn.close()
# second request, for /2 target
conn, addr = sock.accept()
fd = conn.makefile()
try:
line = request = fd.readline()
self.assertEqual(request,
'GET https://localhost:1234/2 HTTP/1.1\r\n')
while line.strip(): # eat request headers
line = fd.readline()
fd.write("HTTP/1.0 200 OK\r\n\r\n")
finally:
fd.close()
conn.close()
sock.close()
server = api.tcp_listener(('0.0.0.0', 5505))
api.spawn(ssl_proxy, server)
import os
os.environ['ALL_PROXY'] = 'localhost:5505'
httpc.get('https://localhost:1234', use_proxy=True, max_retries=1)
def test_server(self):
connected = []
server = api.tcp_listener(('0.0.0.0', 0))
bound_port = server.getsockname()[1]
def accept_twice((conn, addr)):
connected.append(True)
conn.close()
if len(connected) == 2:
server.close()
api.call_after(0, api.connect_tcp, ('127.0.0.1', bound_port))
api.call_after(0, api.connect_tcp, ('127.0.0.1', bound_port))
try:
api.tcp_server(server, accept_twice)
except:
api.sleep(0.1)
raise
assert len(connected) == 2
check_hub()
def test_connect_tcp(self):
def accept_once(listenfd):
try:
conn, addr = listenfd.accept()
fd = conn.makeGreenFile()
conn.close()
fd.write('hello\n')
fd.close()
finally:
listenfd.close()
server = api.tcp_listener(('0.0.0.0', 0))
api.spawn(accept_once, server)
client = api.connect_tcp(('127.0.0.1', server.getsockname()[1]))
fd = client.makeGreenFile()
client.close()
assert fd.readline() == b'hello\n'
assert fd.read() == ''
fd.close()
check_hub()
def test_ssl_proxy(self):
def ssl_proxy(sock):
conn, addr = sock.accept()
fd = conn.makefile()
try:
line = request = fd.readline()
self.assertEqual(request, 'GET https://localhost:1234 HTTP/1.1\r\n')
while line.strip(): # eat request headers
line = fd.readline()
# we're not going to actually proxy to localhost:1234,
# we're just going to return a response on its behalf
fd.write("HTTP/1.0 200 OK\r\n\r\n")
finally:
fd.close()
conn.close()
server = api.tcp_listener(('0.0.0.0', 5505))
api.spawn(ssl_proxy, server)
import os
os.environ['ALL_PROXY'] = 'localhost:5505'
httpc.get('https://localhost:1234', ok=[200], use_proxy=True)
def test_tcp_listener(self):
socket = api.tcp_listener(('0.0.0.0', 0))
assert socket.getsockname()[0] == '0.0.0.0'
socket.close()
check_hub()
sock.getsockname(),
site,
log,
max_http_version=max_http_version)
try:
serv.log.write("httpd starting up on %s\n" % (sock.getsockname(), ))
while True:
try:
new_sock, address = sock.accept()
proto = HttpProtocol(new_sock, address, serv)
pool.execute_async(proto.handle)
api.sleep(0) # sleep to allow other coros to run
except KeyboardInterrupt:
api.get_hub().remove_descriptor(sock.fileno())
serv.log.write("httpd exiting\n")
break
finally:
try:
sock.close()
except socket.error:
pass
if __name__ == '__main__':
class TestSite(object):
def handle_request(self, req):
req.write('hello')
server(api.tcp_listener(('127.0.0.1', 8080)), TestSite())
"""This is a simple example of running a wsgi application with eventlib.
For a more fully-featured server which supports multiple processes,
multiple threads, and graceful code reloading, see:
http://pypi.python.org/pypi/Spawning/
"""
from eventlib import api, wsgi
def hello_world(env, start_response):
if env['PATH_INFO'] != '/':
start_response('404 Not Found', [('Content-Type', 'text/plain')])
return ['Not Found\r\n']
start_response('200 OK', [('Content-Type', 'text/plain')])
return ['Hello, World!\r\n']
wsgi.server(api.tcp_listener(('', 8080)), hello_world)
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
from eventlib import api
def handle_socket(reader, writer):
print("client connected")
while True:
# pass through every non-eof line
x = reader.readline()
if not x: break
writer.write(x)
print(("echoed", x))
print("client disconnected")
print("server socket listening on port 6000")
server = api.tcp_listener(('0.0.0.0', 6000))
while True:
try:
new_sock, address = server.accept()
except KeyboardInterrupt:
break
# handle every new connection with a new coroutine
api.spawn(handle_socket, new_sock.makefile('r'), new_sock.makefile('w'))
