+++ /dev/null
-import cgi
-import collections
-import errno
-import os
-import signal
-import socket
-import sys
-import traceback
-import unittest
-
-import eventlet
-from eventlet import debug
-from eventlet import event
-from eventlet.green import socket as greensocket
-from eventlet.green import ssl
-from eventlet.green import subprocess
-from eventlet import greenio
-from eventlet import greenthread
-from eventlet import support
-from eventlet.support import bytes_to_str, capture_stderr, six
-from eventlet import tpool
-from eventlet import wsgi
-
-import tests
-
-
-certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt')
-private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key')
-
-
-HttpReadResult = collections.namedtuple(
- 'HttpReadResult',
- 'status headers_lower body headers_original')
-
-
-def hello_world(env, start_response):
- if env['PATH_INFO'] == 'notexist':
- start_response('404 Not Found', [('Content-type', 'text/plain')])
- return [b"not found"]
-
- start_response('200 OK', [('Content-type', 'text/plain')])
- return [b"hello world"]
-
-
-def chunked_app(env, start_response):
- start_response('200 OK', [('Content-type', 'text/plain')])
- yield b"this"
- yield b"is"
- yield b"chunked"
-
-
-def chunked_fail_app(environ, start_response):
- """http://rhodesmill.org/brandon/2013/chunked-wsgi/
- """
- headers = [('Content-Type', 'text/plain')]
- start_response('200 OK', headers)
-
- # We start streaming data just fine.
- yield b"The dwarves of yore made mighty spells,"
- yield b"While hammers fell like ringing bells"
-
- # Then the back-end fails!
- try:
- 1 / 0
- except Exception:
- start_response('500 Error', headers, sys.exc_info())
- return
-
- # So rest of the response data is not available.
- yield b"In places deep, where dark things sleep,"
- yield b"In hollow halls beneath the fells."
-
-
-def big_chunks(env, start_response):
- start_response('200 OK', [('Content-type', 'text/plain')])
- line = b'a' * 8192
- for x in range(10):
- yield line
-
-
-def use_write(env, start_response):
- if env['PATH_INFO'] == '/a':
- write = start_response('200 OK', [('Content-type', 'text/plain'),
- ('Content-Length', '5')])
- write(b'abcde')
- if env['PATH_INFO'] == '/b':
- write = start_response('200 OK', [('Content-type', 'text/plain')])
- write(b'abcde')
- return []
-
-
-def chunked_post(env, start_response):
- start_response('200 OK', [('Content-type', 'text/plain')])
- if env['PATH_INFO'] == '/a':
- return [env['wsgi.input'].read()]
- elif env['PATH_INFO'] == '/b':
- return [x for x in iter(lambda: env['wsgi.input'].read(4096), b'')]
- elif env['PATH_INFO'] == '/c':
- return [x for x in iter(lambda: env['wsgi.input'].read(1), b'')]
-
-
-def already_handled(env, start_response):
- start_response('200 OK', [('Content-type', 'text/plain')])
- return wsgi.ALREADY_HANDLED
-
-
-class Site(object):
- def __init__(self):
- self.application = hello_world
-
- def __call__(self, env, start_response):
- return self.application(env, start_response)
-
-
-class IterableApp(object):
-
- def __init__(self, send_start_response=False, return_val=wsgi.ALREADY_HANDLED):
- self.send_start_response = send_start_response
- self.return_val = return_val
- self.env = {}
-
- def __call__(self, env, start_response):
- self.env = env
- if self.send_start_response:
- start_response('200 OK', [('Content-type', 'text/plain')])
- return self.return_val
-
-
-class IterableSite(Site):
- def __call__(self, env, start_response):
- it = self.application(env, start_response)
- for i in it:
- yield i
-
-
-CONTENT_LENGTH = 'content-length'
-
-
-"""
-HTTP/1.1 200 OK
-Date: foo
-Content-length: 11
-
-hello world
-"""
-
-
-def recvall(socket_):
- result = b''
- while True:
- chunk = socket_.recv()
- result += chunk
- if chunk == b'':
- break
-
- return result
-
-
-class ConnectionClosed(Exception):
- pass
-
-
-def send_expect_close(sock, buf):
- # Some tests will induce behavior that causes the remote end to
- # close the connection before all of the data has been written.
- # With small kernel buffer sizes, this can cause an EPIPE error.
- # Since the test expects an early close, this can be ignored.
- try:
- sock.sendall(buf)
- except socket.error as exc:
- if support.get_errno(exc) != errno.EPIPE:
- raise
-
-
-def read_http(sock):
- fd = sock.makefile('rb')
- try:
- response_line = bytes_to_str(fd.readline().rstrip(b'\r\n'))
- except socket.error as exc:
- # TODO find out whether 54 is ok here or not, I see it when running tests
- # on Python 3
- if support.get_errno(exc) in (10053, 54):
- raise ConnectionClosed
- raise
- if not response_line:
- raise ConnectionClosed(response_line)
-
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line)
-
- headers_original = {}
- headers_lower = {}
- for x in header_lines:
- x = x.strip()
- if not x:
- continue
- key, value = bytes_to_str(x).split(':', 1)
- key = key.rstrip()
- value = value.lstrip()
- key_lower = key.lower()
- # FIXME: Duplicate headers are allowed as per HTTP RFC standard,
- # the client and/or intermediate proxies are supposed to treat them
- # as a single header with values concatenated using space (' ') delimiter.
- assert key_lower not in headers_lower, "header duplicated: {0}".format(key)
- headers_original[key] = value
- headers_lower[key_lower] = value
-
- content_length_str = headers_lower.get(CONTENT_LENGTH.lower(), '')
- if content_length_str:
- num = int(content_length_str)
- body = fd.read(num)
- else:
- # read until EOF
- body = fd.read()
-
- result = HttpReadResult(
- status=response_line,
- headers_lower=headers_lower,
- body=body,
- headers_original=headers_original)
- return result
-
-
-class _TestBase(tests.LimitedTestCase):
- def setUp(self):
- super(_TestBase, self).setUp()
- self.logfile = six.StringIO()
- self.site = Site()
- self.killer = None
- self.set_site()
- self.spawn_server()
-
- def tearDown(self):
- greenthread.kill(self.killer)
- eventlet.sleep(0)
- super(_TestBase, self).tearDown()
-
- def spawn_server(self, **kwargs):
- """Spawns a new wsgi server with the given arguments using
- :meth:`spawn_thread`.
-
- Sets self.port to the port of the server
- """
- new_kwargs = dict(max_size=128,
- log=self.logfile,
- site=self.site)
- new_kwargs.update(kwargs)
-
- if 'sock' not in new_kwargs:
- new_kwargs['sock'] = eventlet.listen(('localhost', 0))
-
- self.port = new_kwargs['sock'].getsockname()[1]
- self.spawn_thread(wsgi.server, **new_kwargs)
-
- def spawn_thread(self, target, **kwargs):
- """Spawns a new greenthread using specified target and arguments.
-
- Kills any previously-running server and sets self.killer to the
- greenthread running the target.
- """
- eventlet.sleep(0) # give previous server a chance to start
- if self.killer:
- greenthread.kill(self.killer)
-
- self.killer = eventlet.spawn_n(target, **kwargs)
-
- def set_site(self):
- raise NotImplementedError
-
-
-class TestHttpd(_TestBase):
- def set_site(self):
- self.site = Site()
-
- def test_001_server(self):
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.0\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result = fd.read()
- fd.close()
- # The server responds with the maximum version it supports
- assert result.startswith(b'HTTP'), result
- assert result.endswith(b'hello world'), result
-
- def test_002_keepalive(self):
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('wb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- read_http(sock)
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- read_http(sock)
- fd.close()
- sock.close()
-
- def test_003_passing_non_int_to_read(self):
- # This should go in greenio_test
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- cancel = eventlet.Timeout(1, RuntimeError)
- self.assertRaises(TypeError, fd.read, "This shouldn't work")
- cancel.cancel()
- fd.close()
-
- def test_004_close_keepalive(self):
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('wb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- read_http(sock)
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- read_http(sock)
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- self.assertRaises(ConnectionClosed, read_http, sock)
- fd.close()
-
- @tests.skipped
- def test_005_run_apachebench(self):
- url = 'http://localhost:12346/'
- # ab is apachebench
- subprocess.call(
- [tests.find_command('ab'), '-c', '64', '-n', '1024', '-k', url],
- stdout=subprocess.PIPE)
-
- def test_006_reject_long_urls(self):
- sock = eventlet.connect(
- ('localhost', self.port))
- path_parts = []
- for ii in range(3000):
- path_parts.append('path')
- path = '/'.join(path_parts)
- request = 'GET /%s HTTP/1.0\r\nHost: localhost\r\n\r\n' % path
- send_expect_close(sock, request.encode())
- fd = sock.makefile('rb')
- result = fd.readline()
- if result:
- # windows closes the socket before the data is flushed,
- # so we never get anything back
- status = result.split(b' ')[1]
- self.assertEqual(status, b'414')
- fd.close()
-
- def test_007_get_arg(self):
- # define a new handler that does a get_arg as well as a read_body
- def new_app(env, start_response):
- body = bytes_to_str(env['wsgi.input'].read())
- a = cgi.parse_qs(body).get('a', [1])[0]
- start_response('200 OK', [('Content-type', 'text/plain')])
- return [six.b('a is %s, body is %s' % (a, body))]
-
- self.site.application = new_app
- sock = eventlet.connect(
- ('localhost', self.port))
- request = '\r\n'.join((
- 'POST / HTTP/1.0',
- 'Host: localhost',
- 'Content-Length: 3',
- '',
- 'a=a'))
- fd = sock.makefile('wb')
- fd.write(request.encode())
- fd.flush()
-
- # send some junk after the actual request
- fd.write(b'01234567890123456789')
- result = read_http(sock)
- self.assertEqual(result.body, b'a is a, body is a=a')
- fd.close()
-
- def test_008_correctresponse(self):
- sock = eventlet.connect(('localhost', self.port))
-
- fd = sock.makefile('wb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result_200 = read_http(sock)
- fd.write(b'GET /notexist HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- read_http(sock)
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result_test = read_http(sock)
- self.assertEqual(result_200.status, result_test.status)
- fd.close()
- sock.close()
-
- def test_009_chunked_response(self):
- self.site.application = chunked_app
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- assert b'Transfer-Encoding: chunked' in fd.read()
-
- def test_010_no_chunked_http_1_0(self):
- self.site.application = chunked_app
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.0\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- assert b'Transfer-Encoding: chunked' not in fd.read()
-
- def test_011_multiple_chunks(self):
- self.site.application = big_chunks
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- headers = b''
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- headers += line
- assert b'Transfer-Encoding: chunked' in headers
- chunks = 0
- chunklen = int(fd.readline(), 16)
- while chunklen:
- chunks += 1
- fd.read(chunklen)
- fd.readline() # CRLF
- chunklen = int(fd.readline(), 16)
- assert chunks > 1
- response = fd.read()
- # Require a CRLF to close the message body
- self.assertEqual(response, b'\r\n')
-
- @tests.skip_if_no_ssl
- def test_012_ssl_server(self):
- def wsgi_app(environ, start_response):
- start_response('200 OK', {})
- return [environ['wsgi.input'].read()]
-
- certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt')
- private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key')
-
- server_sock = eventlet.wrap_ssl(eventlet.listen(('localhost', 0)),
- certfile=certificate_file,
- keyfile=private_key_file,
- server_side=True)
- self.spawn_server(sock=server_sock, site=wsgi_app)
-
- sock = eventlet.connect(('localhost', self.port))
- sock = eventlet.wrap_ssl(sock)
- sock.write(
- b'POST /foo HTTP/1.1\r\nHost: localhost\r\n'
- b'Connection: close\r\nContent-length:3\r\n\r\nabc')
- result = recvall(sock)
- assert result.endswith(b'abc')
-
- @tests.skip_if_no_ssl
- def test_013_empty_return(self):
- def wsgi_app(environ, start_response):
- start_response("200 OK", [])
- return [b""]
-
- certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt')
- private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key')
- server_sock = eventlet.wrap_ssl(eventlet.listen(('localhost', 0)),
- certfile=certificate_file,
- keyfile=private_key_file,
- server_side=True)
- self.spawn_server(sock=server_sock, site=wsgi_app)
-
- sock = eventlet.connect(('localhost', server_sock.getsockname()[1]))
- sock = eventlet.wrap_ssl(sock)
- sock.write(b'GET /foo HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- result = recvall(sock)
- assert result[-4:] == b'\r\n\r\n'
-
- def test_014_chunked_post(self):
- self.site.application = chunked_post
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write('PUT /a HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n'
- 'Transfer-Encoding: chunked\r\n\r\n'
- '2\r\noh\r\n4\r\n hai\r\n0\r\n\r\n'.encode())
- fd.flush()
- while True:
- if fd.readline() == b'\r\n':
- break
- response = fd.read()
- assert response == b'oh hai', 'invalid response %s' % response
-
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write('PUT /b HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n'
- 'Transfer-Encoding: chunked\r\n\r\n'
- '2\r\noh\r\n4\r\n hai\r\n0\r\n\r\n'.encode())
- fd.flush()
- while True:
- if fd.readline() == b'\r\n':
- break
- response = fd.read()
- assert response == b'oh hai', 'invalid response %s' % response
-
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write('PUT /c HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n'
- 'Transfer-Encoding: chunked\r\n\r\n'
- '2\r\noh\r\n4\r\n hai\r\n0\r\n\r\n'.encode())
- fd.flush()
- while True:
- if fd.readline() == b'\r\n':
- break
- response = fd.read(8192)
- assert response == b'oh hai', 'invalid response %s' % response
-
- def test_015_write(self):
- self.site.application = use_write
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('wb')
- fd.write(b'GET /a HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- result1 = read_http(sock)
- assert 'content-length' in result1.headers_lower
-
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('wb')
- fd.write(b'GET /b HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- result2 = read_http(sock)
- assert 'transfer-encoding' in result2.headers_lower
- assert result2.headers_lower['transfer-encoding'] == 'chunked'
-
- def test_016_repeated_content_length(self):
- """content-length header was being doubled up if it was set in
- start_response and could also be inferred from the iterator
- """
- def wsgi_app(environ, start_response):
- start_response('200 OK', [('Content-Length', '7')])
- return [b'testing']
- self.site.application = wsgi_app
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'GET /a HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line)
- self.assertEqual(1, len(
- [l for l in header_lines if l.lower().startswith(b'content-length')]))
-
- @tests.skip_if_no_ssl
- def test_017_ssl_zeroreturnerror(self):
-
- def server(sock, site, log):
- try:
- serv = wsgi.Server(sock, sock.getsockname(), site, log)
- client_socket = sock.accept()
- serv.process_request(client_socket)
- return True
- except Exception:
- traceback.print_exc()
- return False
-
- def wsgi_app(environ, start_response):
- start_response('200 OK', [])
- return [environ['wsgi.input'].read()]
-
- certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt')
- private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key')
-
- sock = eventlet.wrap_ssl(
- eventlet.listen(('localhost', 0)),
- certfile=certificate_file, keyfile=private_key_file,
- server_side=True)
- server_coro = eventlet.spawn(server, sock, wsgi_app, self.logfile)
-
- client = eventlet.connect(('localhost', sock.getsockname()[1]))
- client = eventlet.wrap_ssl(client)
- client.write(b'X') # non-empty payload so that SSL handshake occurs
- greenio.shutdown_safe(client)
- client.close()
-
- success = server_coro.wait()
- assert success
-
- def test_018_http_10_keepalive(self):
- # verify that if an http/1.0 client sends connection: keep-alive
- # that we don't close the connection
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('wb')
- fd.write(b'GET / HTTP/1.0\r\nHost: localhost\r\nConnection: keep-alive\r\n\r\n')
- fd.flush()
-
- result1 = read_http(sock)
- assert 'connection' in result1.headers_lower
- self.assertEqual('keep-alive', result1.headers_lower['connection'])
- # repeat request to verify connection is actually still open
- fd.write(b'GET / HTTP/1.0\r\nHost: localhost\r\nConnection: keep-alive\r\n\r\n')
- fd.flush()
- result2 = read_http(sock)
- assert 'connection' in result2.headers_lower
- self.assertEqual('keep-alive', result2.headers_lower['connection'])
- sock.close()
-
- def test_019_fieldstorage_compat(self):
- def use_fieldstorage(environ, start_response):
- cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ)
- start_response('200 OK', [('Content-type', 'text/plain')])
- return [b'hello!']
-
- self.site.application = use_fieldstorage
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('rwb')
- fd.write('POST / HTTP/1.1\r\n'
- 'Host: localhost\r\n'
- 'Connection: close\r\n'
- 'Transfer-Encoding: chunked\r\n\r\n'
- '2\r\noh\r\n'
- '4\r\n hai\r\n0\r\n\r\n'.encode())
- fd.flush()
- assert b'hello!' in fd.read()
-
- def test_020_x_forwarded_for(self):
- request_bytes = (
- b'GET / HTTP/1.1\r\nHost: localhost\r\n'
- + b'X-Forwarded-For: 1.2.3.4, 5.6.7.8\r\n\r\n'
- )
-
- sock = eventlet.connect(('localhost', self.port))
- sock.sendall(request_bytes)
- sock.recv(1024)
- sock.close()
- assert '1.2.3.4,5.6.7.8,127.0.0.1' in self.logfile.getvalue()
-
- # turning off the option should work too
- self.logfile = six.StringIO()
- self.spawn_server(log_x_forwarded_for=False)
-
- sock = eventlet.connect(('localhost', self.port))
- sock.sendall(request_bytes)
- sock.recv(1024)
- sock.close()
- assert '1.2.3.4' not in self.logfile.getvalue()
- assert '5.6.7.8' not in self.logfile.getvalue()
- assert '127.0.0.1' in self.logfile.getvalue()
-
- def test_socket_remains_open(self):
- greenthread.kill(self.killer)
- server_sock = eventlet.listen(('localhost', 0))
- server_sock_2 = server_sock.dup()
- self.spawn_server(sock=server_sock_2)
- # do a single req/response to verify it's up
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.0\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result = fd.read(1024)
- fd.close()
- assert result.startswith(b'HTTP'), result
- assert result.endswith(b'hello world'), result
-
- # shut down the server and verify the server_socket fd is still open,
- # but the actual socketobject passed in to wsgi.server is closed
- greenthread.kill(self.killer)
- eventlet.sleep(0) # make the kill go through
- try:
- server_sock_2.accept()
- # shouldn't be able to use this one anymore
- except socket.error as exc:
- self.assertEqual(support.get_errno(exc), errno.EBADF)
- self.spawn_server(sock=server_sock)
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.0\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result = fd.read(1024)
- fd.close()
- assert result.startswith(b'HTTP'), result
- assert result.endswith(b'hello world'), result
-
- def test_021_environ_clobbering(self):
- def clobberin_time(environ, start_response):
- for environ_var in [
- 'wsgi.version', 'wsgi.url_scheme',
- 'wsgi.input', 'wsgi.errors', 'wsgi.multithread',
- 'wsgi.multiprocess', 'wsgi.run_once', 'REQUEST_METHOD',
- 'SCRIPT_NAME', 'RAW_PATH_INFO', 'PATH_INFO', 'QUERY_STRING',
- 'CONTENT_TYPE', 'CONTENT_LENGTH', 'SERVER_NAME', 'SERVER_PORT',
- 'SERVER_PROTOCOL']:
- environ[environ_var] = None
- start_response('200 OK', [('Content-type', 'text/plain')])
- return []
- self.site.application = clobberin_time
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write('GET / HTTP/1.1\r\n'
- 'Host: localhost\r\n'
- 'Connection: close\r\n'
- '\r\n\r\n'.encode())
- fd.flush()
- assert b'200 OK' in fd.read()
-
- def test_022_custom_pool(self):
- # just test that it accepts the parameter for now
- # TODO(waitall): test that it uses the pool and that you can waitall() to
- # ensure that all clients finished
- p = eventlet.GreenPool(5)
- self.spawn_server(custom_pool=p)
-
- # this stuff is copied from test_001_server, could be better factored
- sock = eventlet.connect(
- ('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.0\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result = fd.read()
- fd.close()
- assert result.startswith(b'HTTP'), result
- assert result.endswith(b'hello world'), result
-
- def test_023_bad_content_length(self):
- sock = eventlet.connect(
- ('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.0\r\nHost: localhost\r\nContent-length: argh\r\n\r\n')
- fd.flush()
- result = fd.read()
- fd.close()
- assert result.startswith(b'HTTP'), result
- assert b'400 Bad Request' in result, result
- assert b'500' not in result, result
-
- def test_024_expect_100_continue(self):
- def wsgi_app(environ, start_response):
- if int(environ['CONTENT_LENGTH']) > 1024:
- start_response('417 Expectation Failed', [('Content-Length', '7')])
- return [b'failure']
- else:
- text = environ['wsgi.input'].read()
- start_response('200 OK', [('Content-Length', str(len(text)))])
- return [text]
- self.site.application = wsgi_app
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 1025\r\n'
- b'Expect: 100-continue\r\n\r\n')
- fd.flush()
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.1 417 Expectation Failed')
- self.assertEqual(result.body, b'failure')
- fd.write(
- b'PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 7\r\n'
- b'Expect: 100-continue\r\n\r\ntesting')
- fd.flush()
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line)
- assert header_lines[0].startswith(b'HTTP/1.1 100 Continue')
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line)
- assert header_lines[0].startswith(b'HTTP/1.1 200 OK')
- assert fd.read(7) == b'testing'
- fd.close()
- sock.close()
-
- def test_024a_expect_100_continue_with_headers(self):
- def wsgi_app(environ, start_response):
- if int(environ['CONTENT_LENGTH']) > 1024:
- start_response('417 Expectation Failed', [('Content-Length', '7')])
- return [b'failure']
- else:
- environ['wsgi.input'].set_hundred_continue_response_headers(
- [('Hundred-Continue-Header-1', 'H1'),
- ('Hundred-Continue-Header-2', 'H2'),
- ('Hundred-Continue-Header-k', 'Hk')])
- text = environ['wsgi.input'].read()
- start_response('200 OK', [('Content-Length', str(len(text)))])
- return [text]
- self.site.application = wsgi_app
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 1025\r\n'
- b'Expect: 100-continue\r\n\r\n')
- fd.flush()
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.1 417 Expectation Failed')
- self.assertEqual(result.body, b'failure')
- fd.write(
- b'PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 7\r\n'
- b'Expect: 100-continue\r\n\r\ntesting')
- fd.flush()
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line.strip())
- assert header_lines[0].startswith(b'HTTP/1.1 100 Continue')
- headers = dict((k, v) for k, v in (h.split(b': ', 1) for h in header_lines[1:]))
- assert b'Hundred-Continue-Header-1' in headers
- assert b'Hundred-Continue-Header-2' in headers
- assert b'Hundred-Continue-Header-K' in headers
- self.assertEqual(b'H1', headers[b'Hundred-Continue-Header-1'])
- self.assertEqual(b'H2', headers[b'Hundred-Continue-Header-2'])
- self.assertEqual(b'Hk', headers[b'Hundred-Continue-Header-K'])
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line)
- assert header_lines[0].startswith(b'HTTP/1.1 200 OK')
- self.assertEqual(fd.read(7), b'testing')
- fd.close()
- sock.close()
-
- def test_024b_expect_100_continue_with_headers_multiple_chunked(self):
- def wsgi_app(environ, start_response):
- environ['wsgi.input'].set_hundred_continue_response_headers(
- [('Hundred-Continue-Header-1', 'H1'),
- ('Hundred-Continue-Header-2', 'H2')])
- text = environ['wsgi.input'].read()
-
- environ['wsgi.input'].set_hundred_continue_response_headers(
- [('Hundred-Continue-Header-3', 'H3')])
- environ['wsgi.input'].send_hundred_continue_response()
-
- text += environ['wsgi.input'].read()
-
- start_response('200 OK', [('Content-Length', str(len(text)))])
- return [text]
- self.site.application = wsgi_app
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'PUT /a HTTP/1.1\r\n'
- b'Host: localhost\r\nConnection: close\r\n'
- b'Transfer-Encoding: chunked\r\n'
- b'Expect: 100-continue\r\n\r\n')
- fd.flush()
-
- # Expect 1st 100-continue response
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line.strip())
- assert header_lines[0].startswith(b'HTTP/1.1 100 Continue')
- headers = dict((k, v) for k, v in (h.split(b': ', 1)
- for h in header_lines[1:]))
- assert b'Hundred-Continue-Header-1' in headers
- assert b'Hundred-Continue-Header-2' in headers
- self.assertEqual(b'H1', headers[b'Hundred-Continue-Header-1'])
- self.assertEqual(b'H2', headers[b'Hundred-Continue-Header-2'])
-
- # Send message 1
- fd.write(b'5\r\nfirst\r\n8\r\n message\r\n0\r\n\r\n')
- fd.flush()
-
- # Expect a 2nd 100-continue response
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line.strip())
- assert header_lines[0].startswith(b'HTTP/1.1 100 Continue')
- headers = dict((k, v) for k, v in (h.split(b': ', 1)
- for h in header_lines[1:]))
- assert b'Hundred-Continue-Header-3' in headers
- self.assertEqual(b'H3', headers[b'Hundred-Continue-Header-3'])
-
- # Send message 2
- fd.write(b'8\r\n, second\r\n8\r\n message\r\n0\r\n\r\n')
- fd.flush()
-
- # Expect final 200-OK
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line.strip())
- assert header_lines[0].startswith(b'HTTP/1.1 200 OK')
-
- self.assertEqual(fd.read(29), b'first message, second message')
- fd.close()
- sock.close()
-
- def test_024c_expect_100_continue_with_headers_multiple_nonchunked(self):
- def wsgi_app(environ, start_response):
-
- environ['wsgi.input'].set_hundred_continue_response_headers(
- [('Hundred-Continue-Header-1', 'H1'),
- ('Hundred-Continue-Header-2', 'H2')])
- text = environ['wsgi.input'].read(13)
-
- environ['wsgi.input'].set_hundred_continue_response_headers(
- [('Hundred-Continue-Header-3', 'H3')])
- environ['wsgi.input'].send_hundred_continue_response()
-
- text += environ['wsgi.input'].read(16)
-
- start_response('200 OK', [('Content-Length', str(len(text)))])
- return [text]
-
- self.site.application = wsgi_app
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'PUT /a HTTP/1.1\r\n'
- b'Host: localhost\r\nConnection: close\r\n'
- b'Content-Length: 29\r\n'
- b'Expect: 100-continue\r\n\r\n')
- fd.flush()
-
- # Expect 1st 100-continue response
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line.strip())
- assert header_lines[0].startswith(b'HTTP/1.1 100 Continue')
- headers = dict((k, v) for k, v in (h.split(b': ', 1)
- for h in header_lines[1:]))
- assert b'Hundred-Continue-Header-1' in headers
- assert b'Hundred-Continue-Header-2' in headers
- self.assertEqual(b'H1', headers[b'Hundred-Continue-Header-1'])
- self.assertEqual(b'H2', headers[b'Hundred-Continue-Header-2'])
-
- # Send message 1
- fd.write(b'first message')
- fd.flush()
-
- # Expect a 2nd 100-continue response
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line.strip())
- assert header_lines[0].startswith(b'HTTP/1.1 100 Continue')
- headers = dict((k, v) for k, v in (h.split(b': ', 1)
- for h in header_lines[1:]))
- assert b'Hundred-Continue-Header-3' in headers
- self.assertEqual(b'H3', headers[b'Hundred-Continue-Header-3'])
-
- # Send message 2
- fd.write(b', second message\r\n')
- fd.flush()
-
- # Expect final 200-OK
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line.strip())
- assert header_lines[0].startswith(b'HTTP/1.1 200 OK')
-
- self.assertEqual(fd.read(29), b'first message, second message')
- fd.close()
- sock.close()
-
- def test_025_accept_errors(self):
- debug.hub_exceptions(True)
- listener = greensocket.socket()
- listener.bind(('localhost', 0))
- # NOT calling listen, to trigger the error
- with capture_stderr() as log:
- self.spawn_server(sock=listener)
- eventlet.sleep(0) # need to enter server loop
- try:
- eventlet.connect(('localhost', self.port))
- self.fail("Didn't expect to connect")
- except socket.error as exc:
- self.assertEqual(support.get_errno(exc), errno.ECONNREFUSED)
-
- log_content = log.getvalue()
- assert 'Invalid argument' in log_content, log_content
- debug.hub_exceptions(False)
-
- def test_026_log_format(self):
- self.spawn_server(log_format="HI %(request_line)s HI")
- sock = eventlet.connect(('localhost', self.port))
- sock.sendall(b'GET /yo! HTTP/1.1\r\nHost: localhost\r\n\r\n')
- sock.recv(1024)
- sock.close()
- assert '\nHI GET /yo! HTTP/1.1 HI\n' in self.logfile.getvalue(), self.logfile.getvalue()
-
- def test_close_chunked_with_1_0_client(self):
- # verify that if we return a generator from our app
- # and we're not speaking with a 1.1 client, that we
- # close the connection
- self.site.application = chunked_app
- sock = eventlet.connect(('localhost', self.port))
-
- sock.sendall(b'GET / HTTP/1.0\r\nHost: localhost\r\nConnection: keep-alive\r\n\r\n')
-
- result = read_http(sock)
- self.assertEqual(result.headers_lower['connection'], 'close')
- self.assertNotEqual(result.headers_lower.get('transfer-encoding'), 'chunked')
- self.assertEqual(result.body, b"thisischunked")
-
- def test_minimum_chunk_size_parameter_leaves_httpprotocol_class_member_intact(self):
- start_size = wsgi.HttpProtocol.minimum_chunk_size
-
- self.spawn_server(minimum_chunk_size=start_size * 2)
- sock = eventlet.connect(('localhost', self.port))
- sock.sendall(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- read_http(sock)
-
- self.assertEqual(wsgi.HttpProtocol.minimum_chunk_size, start_size)
- sock.close()
-
- def test_error_in_chunked_closes_connection(self):
- # From http://rhodesmill.org/brandon/2013/chunked-wsgi/
- self.spawn_server(minimum_chunk_size=1)
-
- self.site.application = chunked_fail_app
- sock = eventlet.connect(('localhost', self.port))
-
- sock.sendall(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
-
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.1 200 OK')
- self.assertEqual(result.headers_lower.get('transfer-encoding'), 'chunked')
- expected_body = (
- b'27\r\nThe dwarves of yore made mighty spells,\r\n'
- b'25\r\nWhile hammers fell like ringing bells\r\n')
- self.assertEqual(result.body, expected_body)
-
- # verify that socket is closed by server
- self.assertEqual(sock.recv(1), b'')
-
- def test_026_http_10_nokeepalive(self):
- # verify that if an http/1.0 client sends connection: keep-alive
- # and the server doesn't accept keep-alives, we close the connection
- self.spawn_server(keepalive=False)
- sock = eventlet.connect(
- ('localhost', self.port))
-
- sock.sendall(b'GET / HTTP/1.0\r\nHost: localhost\r\nConnection: keep-alive\r\n\r\n')
- result = read_http(sock)
- self.assertEqual(result.headers_lower['connection'], 'close')
-
- def test_027_keepalive_chunked(self):
- self.site.application = chunked_post
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('wb')
- common_suffix = (
- b'Host: localhost\r\nTransfer-Encoding: chunked\r\n\r\n' +
- b'10\r\n0123456789abcdef\r\n0\r\n\r\n')
- fd.write(b'PUT /a HTTP/1.1\r\n' + common_suffix)
- fd.flush()
- read_http(sock)
- fd.write(b'PUT /b HTTP/1.1\r\n' + common_suffix)
- fd.flush()
- read_http(sock)
- fd.write(b'PUT /c HTTP/1.1\r\n' + common_suffix)
- fd.flush()
- read_http(sock)
- fd.write(b'PUT /a HTTP/1.1\r\n' + common_suffix)
- fd.flush()
- read_http(sock)
- sock.close()
-
- @tests.skip_if_no_ssl
- def test_028_ssl_handshake_errors(self):
- errored = [False]
-
- def server(sock):
- try:
- wsgi.server(sock=sock, site=hello_world, log=self.logfile)
- errored[0] = 'SSL handshake error caused wsgi.server to exit.'
- except greenthread.greenlet.GreenletExit:
- pass
- except Exception as e:
- errored[0] = 'SSL handshake error raised exception %s.' % e
- raise
- for data in ('', 'GET /non-ssl-request HTTP/1.0\r\n\r\n'):
- srv_sock = eventlet.wrap_ssl(
- eventlet.listen(('localhost', 0)),
- certfile=certificate_file, keyfile=private_key_file,
- server_side=True)
- port = srv_sock.getsockname()[1]
- g = eventlet.spawn_n(server, srv_sock)
- client = eventlet.connect(('localhost', port))
- if data: # send non-ssl request
- client.sendall(data.encode())
- else: # close sock prematurely
- client.close()
- eventlet.sleep(0) # let context switch back to server
- assert not errored[0], errored[0]
- # make another request to ensure the server's still alive
- try:
- client = ssl.wrap_socket(eventlet.connect(('localhost', port)))
- client.write(b'GET / HTTP/1.0\r\nHost: localhost\r\n\r\n')
- result = recvall(client)
- assert result.startswith(b'HTTP'), result
- assert result.endswith(b'hello world')
- except ImportError:
- pass # TODO(openssl): should test with OpenSSL
- greenthread.kill(g)
-
- def test_029_posthooks(self):
- posthook1_count = [0]
- posthook2_count = [0]
-
- def posthook1(env, value, multiplier=1):
- self.assertEqual(env['local.test'], 'test_029_posthooks')
- posthook1_count[0] += value * multiplier
-
- def posthook2(env, value, divisor=1):
- self.assertEqual(env['local.test'], 'test_029_posthooks')
- posthook2_count[0] += value / divisor
-
- def one_posthook_app(env, start_response):
- env['local.test'] = 'test_029_posthooks'
- if 'eventlet.posthooks' not in env:
- start_response('500 eventlet.posthooks not supported',
- [('Content-Type', 'text/plain')])
- else:
- env['eventlet.posthooks'].append(
- (posthook1, (2,), {'multiplier': 3}))
- start_response('200 OK', [('Content-Type', 'text/plain')])
- yield b''
- self.site.application = one_posthook_app
- sock = eventlet.connect(('localhost', self.port))
- fp = sock.makefile('rwb')
- fp.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fp.flush()
- self.assertEqual(fp.readline(), b'HTTP/1.1 200 OK\r\n')
- fp.close()
- sock.close()
- self.assertEqual(posthook1_count[0], 6)
- self.assertEqual(posthook2_count[0], 0)
-
- def two_posthook_app(env, start_response):
- env['local.test'] = 'test_029_posthooks'
- if 'eventlet.posthooks' not in env:
- start_response('500 eventlet.posthooks not supported',
- [('Content-Type', 'text/plain')])
- else:
- env['eventlet.posthooks'].append(
- (posthook1, (4,), {'multiplier': 5}))
- env['eventlet.posthooks'].append(
- (posthook2, (100,), {'divisor': 4}))
- start_response('200 OK', [('Content-Type', 'text/plain')])
- yield b''
- self.site.application = two_posthook_app
- sock = eventlet.connect(('localhost', self.port))
- fp = sock.makefile('rwb')
- fp.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fp.flush()
- self.assertEqual(fp.readline(), b'HTTP/1.1 200 OK\r\n')
- fp.close()
- sock.close()
- self.assertEqual(posthook1_count[0], 26)
- self.assertEqual(posthook2_count[0], 25)
-
- def test_030_reject_long_header_lines(self):
- sock = eventlet.connect(('localhost', self.port))
- request = 'GET / HTTP/1.0\r\nHost: localhost\r\nLong: %s\r\n\r\n' % \
- ('a' * 10000)
- send_expect_close(sock, request.encode())
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.0 400 Header Line Too Long')
-
- def test_031_reject_large_headers(self):
- sock = eventlet.connect(('localhost', self.port))
- headers = ('Name: %s\r\n' % ('a' * 7000,)) * 20
- request = 'GET / HTTP/1.0\r\nHost: localhost\r\n%s\r\n\r\n' % headers
- send_expect_close(sock, request.encode())
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.0 400 Headers Too Large')
-
- def test_032_wsgi_input_as_iterable(self):
- # https://bitbucket.org/eventlet/eventlet/issue/150
- # env['wsgi.input'] returns a single byte at a time
- # when used as an iterator
- g = [0]
-
- def echo_by_iterating(env, start_response):
- start_response('200 OK', [('Content-type', 'text/plain')])
- for chunk in env['wsgi.input']:
- g[0] += 1
- yield chunk
-
- self.site.application = echo_by_iterating
- upload_data = b'123456789abcdef' * 100
- request = (
- 'POST / HTTP/1.0\r\n'
- 'Host: localhost\r\n'
- 'Content-Length: %i\r\n\r\n%s'
- ) % (len(upload_data), bytes_to_str(upload_data))
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(request.encode())
- fd.flush()
- result = read_http(sock)
- self.assertEqual(result.body, upload_data)
- fd.close()
- self.assertEqual(g[0], 1)
-
- def test_zero_length_chunked_response(self):
- def zero_chunked_app(env, start_response):
- start_response('200 OK', [('Content-type', 'text/plain')])
- yield b""
-
- self.site.application = zero_chunked_app
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- response = fd.read().split(b'\r\n')
- headers = []
- while True:
- h = response.pop(0)
- headers.append(h)
- if h == b'':
- break
- assert b'Transfer-Encoding: chunked' in b''.join(headers), headers
- # should only be one chunk of zero size with two blank lines
- # (one terminates the chunk, one terminates the body)
- self.assertEqual(response, [b'0', b'', b''])
-
- def test_configurable_url_length_limit(self):
- self.spawn_server(url_length_limit=20000)
- sock = eventlet.connect(
- ('localhost', self.port))
- path = 'x' * 15000
- request = 'GET /%s HTTP/1.0\r\nHost: localhost\r\n\r\n' % path
- fd = sock.makefile('rwb')
- fd.write(request.encode())
- fd.flush()
- result = fd.readline()
- if result:
- # windows closes the socket before the data is flushed,
- # so we never get anything back
- status = result.split(b' ')[1]
- self.assertEqual(status, b'200')
- fd.close()
-
- def test_aborted_chunked_post(self):
- read_content = event.Event()
- blew_up = [False]
-
- def chunk_reader(env, start_response):
- try:
- content = env['wsgi.input'].read(1024)
- except IOError:
- blew_up[0] = True
- content = b'ok'
- read_content.send(content)
- start_response('200 OK', [('Content-Type', 'text/plain')])
- return [content]
- self.site.application = chunk_reader
- expected_body = 'a bunch of stuff'
- data = "\r\n".join(['PUT /somefile HTTP/1.0',
- 'Transfer-Encoding: chunked',
- '',
- 'def',
- expected_body])
- # start PUT-ing some chunked data but close prematurely
- sock = eventlet.connect(('127.0.0.1', self.port))
- sock.sendall(data.encode())
- sock.close()
- # the test passes if we successfully get here, and read all the data
- # in spite of the early close
- self.assertEqual(read_content.wait(), b'ok')
- assert blew_up[0]
-
- def test_exceptions_close_connection(self):
- def wsgi_app(environ, start_response):
- raise RuntimeError("intentional error")
- self.site.application = wsgi_app
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.1 500 Internal Server Error')
- self.assertEqual(result.headers_lower['connection'], 'close')
- assert 'transfer-encoding' not in result.headers_lower
-
- def test_unicode_raises_error(self):
- def wsgi_app(environ, start_response):
- start_response("200 OK", [])
- yield u"oh hai"
- yield u"non-encodable unicode: \u0230"
- self.site.application = wsgi_app
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.1 500 Internal Server Error')
- self.assertEqual(result.headers_lower['connection'], 'close')
- assert b'unicode' in result.body
-
- def test_path_info_decoding(self):
- def wsgi_app(environ, start_response):
- start_response("200 OK", [])
- yield six.b("decoded: %s" % environ['PATH_INFO'])
- yield six.b("raw: %s" % environ['RAW_PATH_INFO'])
- self.site.application = wsgi_app
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('rwb')
- fd.write(b'GET /a*b@%40%233 HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.1 200 OK')
- assert b'decoded: /a*b@@#3' in result.body
- assert b'raw: /a*b@%40%233' in result.body
-
- def test_ipv6(self):
- try:
- sock = eventlet.listen(('::1', 0), family=socket.AF_INET6)
- except (socket.gaierror, socket.error): # probably no ipv6
- return
- log = six.StringIO()
- # first thing the server does is try to log the IP it's bound to
-
- def run_server():
- try:
- wsgi.server(sock=sock, log=log, site=Site())
- except ValueError:
- log.write(b'broken')
-
- self.spawn_thread(run_server)
-
- logval = log.getvalue()
- while not logval:
- eventlet.sleep(0.0)
- logval = log.getvalue()
- if 'broked' in logval:
- self.fail('WSGI server raised exception with ipv6 socket')
-
- def test_debug(self):
- self.spawn_server(debug=False)
-
- def crasher(env, start_response):
- raise RuntimeError("intentional crash")
- self.site.application = crasher
-
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('wb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result1 = read_http(sock)
- self.assertEqual(result1.status, 'HTTP/1.1 500 Internal Server Error')
- self.assertEqual(result1.body, b'')
- self.assertEqual(result1.headers_lower['connection'], 'close')
- assert 'transfer-encoding' not in result1.headers_lower
-
- # verify traceback when debugging enabled
- self.spawn_server(debug=True)
- self.site.application = crasher
- sock = eventlet.connect(('localhost', self.port))
- fd = sock.makefile('wb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- fd.flush()
- result2 = read_http(sock)
- self.assertEqual(result2.status, 'HTTP/1.1 500 Internal Server Error')
- assert b'intentional crash' in result2.body, result2.body
- assert b'RuntimeError' in result2.body, result2.body
- assert b'Traceback' in result2.body, result2.body
- self.assertEqual(result2.headers_lower['connection'], 'close')
- assert 'transfer-encoding' not in result2.headers_lower
-
- def test_client_disconnect(self):
- """Issue #95 Server must handle disconnect from client in the middle of response
- """
- def long_response(environ, start_response):
- start_response('200 OK', [('Content-Length', '9876')])
- yield b'a' * 9876
-
- server_sock = eventlet.listen(('localhost', 0))
- self.port = server_sock.getsockname()[1]
- server = wsgi.Server(server_sock, server_sock.getsockname(), long_response,
- log=self.logfile)
-
- def make_request():
- sock = eventlet.connect(server_sock.getsockname())
- sock.send(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- sock.close()
-
- request_thread = eventlet.spawn(make_request)
- server_conn = server_sock.accept()
- # Next line must not raise IOError -32 Broken pipe
- server.process_request(server_conn)
- request_thread.wait()
- server_sock.close()
-
- def test_server_connection_timeout_exception(self):
- # Handle connection socket timeouts
- # https://bitbucket.org/eventlet/eventlet/issue/143/
- # Runs tests.wsgi_test_conntimeout in a separate process.
- testcode_path = os.path.join(
- os.path.dirname(os.path.abspath(__file__)),
- 'wsgi_test_conntimeout.py')
- output = tests.run_python(testcode_path)
- sections = output.split(b"SEPERATOR_SENTINEL")
- # first section is empty
- self.assertEqual(3, len(sections), output)
- # if the "BOOM" check fails, it's because our timeout didn't happen
- # (if eventlet stops using file.readline() to read HTTP headers,
- # for instance)
- for runlog in sections[1:]:
- debug = False if "debug set to: False" in runlog else True
- if debug:
- self.assertTrue("timed out" in runlog)
- self.assertTrue("BOOM" in runlog)
- self.assertFalse("Traceback" in runlog)
-
- def test_server_socket_timeout(self):
- self.spawn_server(socket_timeout=0.1)
- sock = eventlet.connect(('localhost', self.port))
- sock.send(b'GET / HTTP/1.1\r\n')
- eventlet.sleep(0.1)
- try:
- read_http(sock)
- assert False, 'Expected ConnectionClosed exception'
- except ConnectionClosed:
- pass
-
- def test_disable_header_name_capitalization(self):
- # Disable HTTP header name capitalization
- #
- # https://github.com/eventlet/eventlet/issues/80
- random_case_header = ('eTAg', 'TAg-VAluE')
-
- def wsgi_app(environ, start_response):
- start_response('200 oK', [random_case_header])
- return [b'']
-
- self.spawn_server(site=wsgi_app, capitalize_response_headers=False)
-
- sock = eventlet.connect(('localhost', self.port))
- sock.sendall(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
- result = read_http(sock)
- sock.close()
- self.assertEqual(result.status, 'HTTP/1.1 200 oK')
- self.assertEqual(result.headers_lower[random_case_header[0].lower()], random_case_header[1])
- self.assertEqual(result.headers_original[random_case_header[0]], random_case_header[1])
-
-
-def read_headers(sock):
- fd = sock.makefile('rb')
- try:
- response_line = fd.readline()
- except socket.error as exc:
- if support.get_errno(exc) == 10053:
- raise ConnectionClosed
- raise
- if not response_line:
- raise ConnectionClosed
-
- header_lines = []
- while True:
- line = fd.readline()
- if line == b'\r\n':
- break
- else:
- header_lines.append(line)
- headers = dict()
- for x in header_lines:
- x = x.strip()
- if not x:
- continue
- key, value = x.split(b': ', 1)
- assert key.lower() not in headers, "%s header duplicated" % key
- headers[bytes_to_str(key.lower())] = bytes_to_str(value)
- return bytes_to_str(response_line), headers
-
-
-class IterableAlreadyHandledTest(_TestBase):
- def set_site(self):
- self.site = IterableSite()
-
- def get_app(self):
- return IterableApp(True)
-
- def test_iterable_app_keeps_socket_open_unless_connection_close_sent(self):
- self.site.application = self.get_app()
- sock = eventlet.connect(
- ('localhost', self.port))
-
- fd = sock.makefile('rwb')
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
-
- fd.flush()
- response_line, headers = read_headers(sock)
- self.assertEqual(response_line, 'HTTP/1.1 200 OK\r\n')
- assert 'connection' not in headers
- fd.write(b'GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
- fd.flush()
- result = read_http(sock)
- self.assertEqual(result.status, 'HTTP/1.1 200 OK')
- self.assertEqual(result.headers_lower.get('transfer-encoding'), 'chunked')
- self.assertEqual(result.body, b'0\r\n\r\n') # Still coming back chunked
-
-
-class ProxiedIterableAlreadyHandledTest(IterableAlreadyHandledTest):
- # same thing as the previous test but ensuring that it works with tpooled
- # results as well as regular ones
- @tests.skip_with_pyevent
- def get_app(self):
- return tpool.Proxy(super(ProxiedIterableAlreadyHandledTest, self).get_app())
-
- def tearDown(self):
- tpool.killall()
- super(ProxiedIterableAlreadyHandledTest, self).tearDown()
-
-
-class TestChunkedInput(_TestBase):
- dirt = ""
- validator = None
-
- def application(self, env, start_response):
- input = env['wsgi.input']
- response = []
-
- pi = env["PATH_INFO"]
-
- if pi == "/short-read":
- d = input.read(10)
- response = [d]
- elif pi == "/lines":
- for x in input:
- response.append(x)
- elif pi == "/ping":
- input.read()
- response.append(b"pong")
- elif pi.startswith("/yield_spaces"):
- if pi.endswith('override_min'):
- env['eventlet.minimum_write_chunk_size'] = 1
- self.yield_next_space = False
-
- def response_iter():
- yield b' '
- num_sleeps = 0
- while not self.yield_next_space and num_sleeps < 200:
- eventlet.sleep(.01)
- num_sleeps += 1
-
- yield b' '
-
- start_response('200 OK',
- [('Content-Type', 'text/plain'),
- ('Content-Length', '2')])
- return response_iter()
- else:
- raise RuntimeError("bad path")
-
- start_response('200 OK', [('Content-Type', 'text/plain')])
- return response
-
- def connect(self):
- return eventlet.connect(('localhost', self.port))
-
- def set_site(self):
- self.site = Site()
- self.site.application = self.application
-
- def chunk_encode(self, chunks, dirt=None):
- if dirt is None:
- dirt = self.dirt
-
- b = ""
- for c in chunks:
- b += "%x%s\r\n%s\r\n" % (len(c), dirt, c)
- return b
-
- def body(self, dirt=None):
- return self.chunk_encode(["this", " is ", "chunked", "\nline",
- " 2", "\n", "line3", ""], dirt=dirt)
-
- def ping(self, fd):
- fd.sendall(b"GET /ping HTTP/1.1\r\n\r\n")
- self.assertEqual(read_http(fd).body, b"pong")
-
- def test_short_read_with_content_length(self):
- body = self.body()
- req = "POST /short-read HTTP/1.1\r\ntransfer-encoding: Chunked\r\n" \
- "Content-Length:1000\r\n\r\n" + body
-
- fd = self.connect()
- fd.sendall(req.encode())
- self.assertEqual(read_http(fd).body, b"this is ch")
-
- self.ping(fd)
- fd.close()
-
- def test_short_read_with_zero_content_length(self):
- body = self.body()
- req = "POST /short-read HTTP/1.1\r\ntransfer-encoding: Chunked\r\n" \
- "Content-Length:0\r\n\r\n" + body
- fd = self.connect()
- fd.sendall(req.encode())
- self.assertEqual(read_http(fd).body, b"this is ch")
-
- self.ping(fd)
- fd.close()
-
- def test_short_read(self):
- body = self.body()
- req = "POST /short-read HTTP/1.1\r\ntransfer-encoding: Chunked\r\n\r\n" + body
-
- fd = self.connect()
- fd.sendall(req.encode())
- self.assertEqual(read_http(fd).body, b"this is ch")
-
- self.ping(fd)
- fd.close()
-
- def test_dirt(self):
- body = self.body(dirt="; here is dirt\0bla")
- req = "POST /ping HTTP/1.1\r\ntransfer-encoding: Chunked\r\n\r\n" + body
-
- fd = self.connect()
- fd.sendall(req.encode())
- self.assertEqual(read_http(fd).body, b"pong")
-
- self.ping(fd)
- fd.close()
-
- def test_chunked_readline(self):
- body = self.body()
- req = "POST /lines HTTP/1.1\r\nContent-Length: %s\r\n" \
- "transfer-encoding: Chunked\r\n\r\n%s" % (len(body), body)
-
- fd = self.connect()
- fd.sendall(req.encode())
- self.assertEqual(read_http(fd).body, b'this is chunked\nline 2\nline3')
- fd.close()
-
- def test_chunked_readline_wsgi_override_minimum_chunk_size(self):
-
- fd = self.connect()
- fd.sendall(b"POST /yield_spaces/override_min HTTP/1.1\r\nContent-Length: 0\r\n\r\n")
-
- resp_so_far = b''
- with eventlet.Timeout(.1):
- while True:
- one_byte = fd.recv(1)
- resp_so_far += one_byte
- if resp_so_far.endswith(b'\r\n\r\n'):
- break
- self.assertEqual(fd.recv(1), b' ')
- try:
- with eventlet.Timeout(.1):
- fd.recv(1)
- except eventlet.Timeout:
- pass
- else:
- assert False
- self.yield_next_space = True
-
- with eventlet.Timeout(.1):
- self.assertEqual(fd.recv(1), b' ')
-
- def test_chunked_readline_wsgi_not_override_minimum_chunk_size(self):
-
- fd = self.connect()
- fd.sendall(b"POST /yield_spaces HTTP/1.1\r\nContent-Length: 0\r\n\r\n")
-
- resp_so_far = b''
- try:
- with eventlet.Timeout(.1):
- while True:
- one_byte = fd.recv(1)
- resp_so_far += one_byte
- if resp_so_far.endswith(b'\r\n\r\n'):
- break
- self.assertEqual(fd.recv(1), b' ')
- except eventlet.Timeout:
- pass
- else:
- assert False
-
- def test_close_before_finished(self):
- got_signal = []
-
- def handler(*args):
- got_signal.append(1)
- raise KeyboardInterrupt()
-
- signal.signal(signal.SIGALRM, handler)
- signal.alarm(1)
-
- try:
- body = '4\r\nthi'
- req = "POST /short-read HTTP/1.1\r\ntransfer-encoding: Chunked\r\n\r\n" + body
-
- fd = self.connect()
- fd.sendall(req.encode())
- fd.close()
- eventlet.sleep(0.0)
- finally:
- signal.alarm(0)
- signal.signal(signal.SIGALRM, signal.SIG_DFL)
-
- assert not got_signal, "caught alarm signal. infinite loop detected."
-
-
-if __name__ == '__main__':
- unittest.main()
Code Review / packages / trusty / python-eventlet.git / blobdiff