def test_two_servers(self):
def test_app(env, start_response):
start_response('200 OK', {})
return ['PONG']
fake_ssl_server = wsgi.Server(self.conf, "fake_ssl", test_app,
host="127.0.0.1", port=0, use_ssl=True)
fake_ssl_server.start()
self.assertNotEqual(0, fake_ssl_server.port)
fake_server = wsgi.Server(self.conf, "fake", test_app,
host="127.0.0.1", port=0)
fake_server.start()
self.assertNotEqual(0, fake_server.port)
response = requests.post(
'https://127.0.0.1:%s/' % fake_ssl_server.port,
verify=os.path.join(SSL_CERT_DIR, 'ca.crt'), data='PING')
self.assertEqual('PONG', response.text)
response = requests.post(
'http://127.0.0.1:%s/' % fake_server.port, data='PING')
self.assertEqual('PONG', response.text)
fake_ssl_server.stop()
fake_ssl_server.wait()
fake_server.stop()
fake_server.wait()
def test_two_servers(self):
def test_app(env, start_response):
start_response('200 OK', {})
return ['PONG']
fake_ssl_server = wsgi.Server(self.conf, "fake_ssl", test_app,
host="127.0.0.1", port=0, use_ssl=True)
fake_ssl_server.start()
self.assertNotEqual(0, fake_ssl_server.port)
fake_server = wsgi.Server(self.conf, "fake", test_app,
host="127.0.0.1", port=0)
fake_server.start()
self.assertNotEqual(0, fake_server.port)
response = requesting(
method='GET',
host='127.0.0.1',
port=fake_ssl_server.port,
ca_certs=os.path.join(SSL_CERT_DIR, 'ca.crt'),
)
self.assertEqual('PONG', response[-4:])
response = requesting(
method='GET',
host='127.0.0.1',
port=fake_server.port,
)
self.assertEqual('PONG', response[-4:])
fake_ssl_server.stop()
fake_ssl_server.wait()
fake_server.stop()
fake_server.wait()
def test_ssl_server(self):
def test_app(env, start_response):
start_response('200 OK', {})
return ['PONG']
fake_ssl_server = wsgi.Server(self.conf,
"fake_ssl",
test_app,
host="127.0.0.1",
port=0,
use_ssl=True)
fake_ssl_server.start()
self.assertNotEqual(0, fake_ssl_server.port)
cli = eventlet.connect(("localhost", fake_ssl_server.port))
ca_certs_name = os.path.join(SSL_CERT_DIR, 'ca.crt')
cli = eventlet.wrap_ssl(cli, ca_certs=ca_certs_name)
cli.write('POST / HTTP/1.1\r\nHost: localhost\r\n'
'Connection: close\r\nContent-length:4\r\n\r\nPING')
response = cli.read(8192)
self.assertEqual(response[-4:], "PONG")
fake_ssl_server.stop()
fake_ssl_server.wait()
def test_app_using_ipv6_and_ssl(self):
greetings = 'Hello, World!!!'
@webob.dec.wsgify
def hello_world(req):
return greetings
server = wsgi.Server(self.conf, "fake_ssl",
hello_world,
host="::1",
port=0,
use_ssl=True)
server.start()
response = requesting(
method='GET',
host='::1',
port=server.port,
ca_certs=os.path.join(SSL_CERT_DIR, 'ca.crt'),
address_familly=socket.AF_INET6
)
self.assertEqual(greetings, response[-15:])
server.stop()
server.wait()
def test_start_random_port(self):
server = wsgi.Server(self.conf, "test_random_port", None,
host="127.0.0.1", port=0)
server.start()
self.assertNotEqual(0, server.port)
server.stop()
server.wait()
def test_start_random_port_with_ipv6(self):
server = wsgi.Server(self.conf, "test_random_port", None,
host="::1", port=0)
server.start()
self.assertEqual("::1", server.host)
self.assertNotEqual(0, server.port)
server.stop()
server.wait()
def test_server_pool_waitall(self):
# test pools waitall method gets called while stopping server
server = wsgi.Server(self.conf, "test_server", None, host="127.0.0.1")
server.start()
with mock.patch.object(server._pool, 'waitall') as mock_waitall:
server.stop()
server.wait()
mock_waitall.assert_called_once_with()
def get_wsgi_server():
LOG.audit(_("Starting nova-xvpvncproxy node (version %s)"),
version.version_string_with_vcs())
return wsgi.Server("XCP VNC Proxy",
XCPVNCProxy(),
protocol=SafeHttpProtocol,
host=FLAGS.xvpvncproxy_host,
port=FLAGS.xvpvncproxy_port)
def get_wsgi_server():
LOG.info(_LI("Starting nova-xvpvncproxy node (version %s)"),
version.version_string_with_package())
return wsgi.Server("XCP VNC Proxy",
XCPVNCProxy(),
protocol=SafeHttpProtocol,
host=CONF.vnc.xvpvncproxy_host,
port=CONF.vnc.xvpvncproxy_port)
def get_wsgi_server(self,
sock,
wsgi_app,
protocol=HttpOnlyProtocol,
debug=False):
return wsgi.Server(sock,
sock.getsockname(),
custom_wsgi_app,
protocol=protocol,
debug=debug)
def get_wsgi_server(self,
sock,
wsgi_app,
protocol=HttpOnlyProtocol,
debug=False):
"""Get the WSGI server used to process requests."""
return wsgi.Server(sock,
sock.getsockname(),
wsgi_app,
protocol=protocol,
debug=debug)
def start(self):
if not self._starting:
self._starting = True
self._wsgi_app = WsgiApp(self)
self._sock = eventlet.listen(self.bind_addr)
self._serv = wsgi.Server(self._sock,
self._sock.getsockname(),
self._wsgi_app,
protocol=HttpOnlyProtocol,
debug=False)
self._gt = self.container.spawn_managed_thread(
self.run, protected=True)
def get_wsgi_server():
LOG.info(_LI("Starting nova-xvpvncproxy node (version %s)"),
version.version_string_with_package())
LOG.warning('The nova-xvpvncproxy service is deprecated as it is Xen '
'specific and has effectively been replaced by noVNC '
'and the nova-novncproxy service.')
return wsgi.Server("XCP VNC Proxy",
XCPVNCProxy(),
protocol=SafeHttpProtocol,
host=CONF.vnc.xvpvncproxy_host,
port=CONF.vnc.xvpvncproxy_port)
def test_reset_pool_size_to_default(self):
server = wsgi.Server(self.conf, "test_resize", None,
host="127.0.0.1", max_url_len=16384)
server.start()
# Stopping the server, which in turn sets pool size to 0
server.stop()
self.assertEqual(0, server._pool.size)
# Resetting pool size to default
server.reset()
server.start()
self.assertEqual(CONF.wsgi_default_pool_size, server._pool.size)
def test_wsgi_keep_alive(self):
self.config(wsgi_keep_alive=False)
# mocking eventlet spawn method to check it is called with
# configured 'wsgi_keep_alive' value.
with mock.patch.object(eventlet,
'spawn') as mock_spawn:
server = wsgi.Server(self.conf, "test_app", None,
host="127.0.0.1", port=0)
server.start()
_, kwargs = mock_spawn.call_args
self.assertEqual(self.conf.wsgi_keep_alive,
kwargs['keepalive'])
server.stop()
def test_client_socket_timeout(self):
self.config(client_socket_timeout=5)
# mocking eventlet spawn method to check it is called with
# configured 'client_socket_timeout' value.
with mock.patch.object(eventlet,
'spawn') as mock_spawn:
server = wsgi.Server(self.conf, "test_app", None,
host="127.0.0.1", port=0)
server.start()
_, kwargs = mock_spawn.call_args
self.assertEqual(self.conf.client_socket_timeout,
kwargs['socket_timeout'])
server.stop()
def test_server_with_unix_socket(self):
socket_file = self.get_temp_file_path('sock')
socket_mode = 0o644
server = wsgi.Server(self.conf, "test_socket_options", None,
socket_family=socket.AF_UNIX,
socket_mode=socket_mode,
socket_file=socket_file)
self.assertEqual(socket_file, server.socket.getsockname())
self.assertEqual(socket_mode,
os.stat(socket_file).st_mode & 0o777)
server.start()
self.assertFalse(server._server.dead)
server.stop()
server.wait()
self.assertTrue(server._server.dead)
def test_socket_options_for_ssl_server(self):
# test normal socket options has set properly
self.config(tcp_keepidle=500)
server = wsgi.Server(self.conf, "test_socket_options", None,
host="127.0.0.1", port=0, use_ssl=True)
server.start()
sock = server.socket
self.assertEqual(1, sock.getsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR))
self.assertEqual(1, sock.getsockopt(socket.SOL_SOCKET,
socket.SO_KEEPALIVE))
if hasattr(socket, 'TCP_KEEPIDLE'):
self.assertEqual(CONF.tcp_keepidle,
sock.getsockopt(socket.IPPROTO_TCP,
socket.TCP_KEEPIDLE))
server.stop()
server.wait()
def test_uri_length_limit(self):
eventlet.monkey_patch(os=False, thread=False)
server = wsgi.Server(self.conf, "test_uri_length_limit", None,
host="127.0.0.1", max_url_len=16384, port=33337)
server.start()
self.assertFalse(server._server.dead)
uri = "http://127.0.0.1:%d/%s" % (server.port, 10000 * 'x')
resp = requests.get(uri, proxies={"http": ""})
eventlet.sleep(0)
self.assertNotEqual(requests.codes.REQUEST_URI_TOO_LARGE,
resp.status_code)
uri = "http://127.0.0.1:%d/%s" % (server.port, 20000 * 'x')
resp = requests.get(uri, proxies={"http": ""})
eventlet.sleep(0)
self.assertEqual(requests.codes.REQUEST_URI_TOO_LARGE,
resp.status_code)
server.stop()
server.wait()
def test_app_using_ipv6_and_ssl(self):
greetings = 'Hello, World!!!'
@webob.dec.wsgify
def hello_world(req):
return greetings
server = wsgi.Server(self.conf, "fake_ssl",
hello_world,
host="::1",
port=0,
use_ssl=True)
server.start()
response = requests.get('https://[::1]:%d/' % server.port,
verify=os.path.join(SSL_CERT_DIR, 'ca.crt'))
self.assertEqual(greetings, response.text)
server.stop()
server.wait()
def server(sock,
site,
log=None,
environ=None,
max_size=None,
max_http_version=wsgiserver.DEFAULT_MAX_HTTP_VERSION,
protocol=wsgiserver.HttpProtocol,
server_event=None,
minimum_chunk_size=None,
log_x_forwarded_for=True,
custom_pool=None,
keepalive=True,
log_format=wsgiserver.DEFAULT_LOG_FORMAT):
sock.settimeout(0.001)
#sock.settimeout(None)
serv = wsgiserver.Server(sock,
sock.getsockname(),
site,
log,
environ=environ,
max_http_version=max_http_version,
protocol=protocol,
minimum_chunk_size=minimum_chunk_size,
log_x_forwarded_for=log_x_forwarded_for,
keepalive=keepalive,
log_format=log_format)
if server_event is not None:
server_event.send(serv)
if max_size is None:
max_size = wsgiserver.DEFAULT_MAX_SIMULTANEOUS_REQUESTS
if custom_pool is not None:
pool = custom_pool
else:
pool = greenpool.GreenPool(max_size)
try:
host, port = sock.getsockname()
port = ':%s' % (port, )
if hasattr(sock, 'do_handshake'):
scheme = 'https'
if port == ':443':
port = ''
else:
scheme = 'http'
if port == ':80':
port = ''
serv.log.write("(%s) wsgi starting up on %s://%s%s/\n" %
(os.getpid(), scheme, host, port))
while True:
yield
try:
#select([sock], [], [],
try:
client_socket = sock.accept()
except socket.timeout:
continue
try:
pool.spawn_n(serv.process_request, client_socket)
except AttributeError:
warnings.warn("wsgi's pool should be an instance of " \
"eventlet.greenpool.GreenPool, is %s. Please convert your"\
" call site to use GreenPool instead" % type(pool),
DeprecationWarning, stacklevel=2)
pool.execute_async(serv.process_request, client_socket)
except wsgiserver.ACCEPT_EXCEPTIONS, e:
if get_errno(e) not in ACCEPT_ERRNO:
raise
except (KeyboardInterrupt, SystemExit):
serv.log.write("wsgi exiting\n")
break
def get_wsgi_srv(self):
sock = self.ev_sock if not self.sslargs else wrap_ssl(self.ev_sock, **self.sslargs)
addr = self.ev_sock.getsockname()
return wsgi.Server(sock, addr, self.get_wsgi_app(), **self.srvargs)
def test_no_app(self):
server = wsgi.Server(self.conf, "test_app", None)
self.assertEqual("test_app", server.name)
def test_custom_max_header_line(self):
self.config(max_header_line=4096) # Default value is 16384
wsgi.Server(self.conf, "test_custom_max_header_line", None)
self.assertEqual(eventlet.wsgi.MAX_HEADER_LINE,
self.conf.max_header_line)
