def test_ssl_sending_messages(self):
s = eventlet.wrap_ssl(
eventlet.listen(("localhost", 0)), certfile=certificate_file, keyfile=private_key_file, server_side=True
)
self.spawn_server(sock=s)
connect = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = eventlet.wrap_ssl(eventlet.connect(("localhost", self.port)))
sock.sendall("\r\n".join(connect) + "\r\n\r\n^n:ds[4U")
first_resp = sock.recv(1024)
# make sure it sets the wss: protocol on the location header
loc_line = [x for x in first_resp.split("\r\n") if x.lower().startswith("sec-websocket-location")][0]
self.assert_("wss://localhost" in loc_line, "Expecting wss protocol in location: %s" % loc_line)
sock.sendall("\x00hello\xFF")
result = sock.recv(1024)
self.assertEqual(result, "\x00hello\xff")
sock.sendall("\x00start")
eventlet.sleep(0.001)
sock.sendall(" end\xff")
result = sock.recv(1024)
self.assertEqual(result, "\x00start end\xff")
greenio.shutdown_safe(sock)
sock.close()
eventlet.sleep(0.01)
def test_connect_ssl(self):
def accept_once(listenfd):
try:
conn, addr = listenfd.accept()
conn.write(b'hello\r\n')
greenio.shutdown_safe(conn)
conn.close()
finally:
greenio.shutdown_safe(listenfd)
listenfd.close()
server = api.ssl_listener(('0.0.0.0', 0),
self.certificate_file,
self.private_key_file)
api.spawn(accept_once, server)
raw_client = eventlet.connect(('127.0.0.1', server.getsockname()[1]))
client = util.wrap_ssl(raw_client)
fd = socket._fileobject(client, 'rb', 8192)
assert fd.readline() == b'hello\r\n'
try:
self.assertEqual(b'', fd.read(10))
except greenio.SSL.ZeroReturnError:
# if it's a GreenSSL object it'll do this
pass
greenio.shutdown_safe(client)
client.close()
check_hub()
def test_recv_after_ssl_connect(self):
def serve(listener):
sock, addr = listener.accept()
sock.sendall(b'hjk')
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_client = ssl.wrap_socket(raw_client)
# Important: We need to call connect() on an SSL socket, not a plain one.
# The bug was affecting that particular combination (create plain socket,
# wrap, call connect() on the SSL socket and try to recv) on Python 3.5.
ssl_client.connect(sock.getsockname())
# The call to recv used to fail with:
# Traceback (most recent call last):
# File "tests/ssl_test.py", line 99, in test_recv_after_ssl_connect
# self.assertEqual(ssl_client.recv(3), b'hjk')
# File "eventlet/green/ssl.py", line 194, in recv
# return self._base_recv(buflen, flags, into=False)
# File "eventlet/green/ssl.py", line 227, in _base_recv
# read = self.read(nbytes)
# File "eventlet/green/ssl.py", line 139, in read
# super(GreenSSLSocket, self).read, *args, **kwargs)
# File "eventlet/green/ssl.py", line 113, in _call_trampolining
# return func(*a, **kw)
# File "PYTHONLIB/python3.5/ssl.py", line 791, in read
# return self._sslobj.read(len, buffer)
# TypeError: read() argument 2 must be read-write bytes-like object, not None
self.assertEqual(ssl_client.recv(3), b'hjk')
greenio.shutdown_safe(ssl_client)
ssl_client.close()
server_coro.wait()
def shutdown_sockets(self):
"""
Shutdown any listen sockets.
"""
greenio.shutdown_safe(self.sock)
self.sock.close()
def serve(listener):
sock, addr = listener.accept()
# to simulate condition mentioned in GH-17
sock._sslobj = None
sock.sendall(b'some data')
greenio.shutdown_safe(sock)
sock.close()
def shutdown_sockets(self):
"""
Shutdown any listen sockets.
"""
for sock in self.port_pid_state.all_socks():
greenio.shutdown_safe(sock)
sock.close()
def finish(self):
try:
BaseHTTPServer.BaseHTTPRequestHandler.finish(self)
except socket.error as e:
# Broken pipe, connection reset by peer
if support.get_errno(e) not in BROKEN_SOCK:
raise
greenio.shutdown_safe(self.connection)
self.connection.close()
def accept_once(listenfd):
try:
conn, addr = listenfd.accept()
conn.write(b'hello\r\n')
greenio.shutdown_safe(conn)
conn.close()
finally:
greenio.shutdown_safe(listenfd)
listenfd.close()
def forget_port(self, port):
"""
Idempotently forget a port, closing the listen socket at most once.
"""
orphan_data = self.sock_data_by_port.pop(port, None)
if orphan_data:
greenio.shutdown_safe(orphan_data["sock"])
orphan_data["sock"].close()
self.logger.notice("Closing unnecessary sock for port %d", port)
def serve(sock):
try:
name = sock.recv(8)
sock.sendall(b'hello ' + name)
except Exception:
# ignore evil clients
pass
finally:
greenio.shutdown_safe(sock)
sock.close()
def forget_port(self, port):
"""
Idempotently forget a port, closing the listen socket at most once.
"""
orphan_data = self.sock_data_by_port.pop(port, None)
if orphan_data:
greenio.shutdown_safe(orphan_data['sock'])
orphan_data['sock'].close()
self.logger.notice('Closing unnecessary sock for port %d', port)
def serve(sock):
try:
name = sock.recv(8)
sock.sendall(b'hello ' + name)
except Exception:
# ignore evil clients
pass
finally:
greenio.shutdown_safe(sock)
sock.close()
def stop(self):
LOG.info("shutting down: requests left: %s", self.pool.running())
self.running = False
self.pool.resize(0)
# self.pool.waitall()
if self.socket:
eventlet_greenio.shutdown_safe(self.socket)
self.socket.close()
self.running = False
def test_ssl_connect(self):
def serve(listener):
sock, addr = listener.accept()
sock.recv(8192)
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_client = ssl.wrap_socket(raw_client)
ssl_client.connect(sock.getsockname())
ssl_client.sendall(b'abc')
greenio.shutdown_safe(ssl_client)
ssl_client.close()
server_coro.wait()
def test_ssl_connect(self):
def serve(listener):
sock, addr = listener.accept()
stuff = sock.read(8192)
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_client = util.wrap_ssl(raw_client)
ssl_client.connect(('127.0.0.1', sock.getsockname()[1]))
ssl_client.write('abc')
greenio.shutdown_safe(ssl_client)
ssl_client.close()
server_coro.wait()
def test_ssl_connect(self):
def serve(listener):
sock, addr = listener.accept()
stuff = sock.read(8192)
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_client = util.wrap_ssl(raw_client)
ssl_client.connect(('127.0.0.1', sock.getsockname()[1]))
ssl_client.write('abc')
greenio.shutdown_safe(ssl_client)
ssl_client.close()
server_coro.wait()
def test_ssl_connect(self):
def serve(listener):
sock, addr = listener.accept()
sock.recv(8192)
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_client = ssl.wrap_socket(raw_client)
ssl_client.connect(sock.getsockname())
ssl_client.sendall(b'abc')
greenio.shutdown_safe(ssl_client)
ssl_client.close()
server_coro.wait()
def test_ssl_close(self):
def serve(listener):
sock, addr = listener.accept()
sock.recv(8192)
try:
self.assertEqual(b'', sock.recv(8192))
except greenio.SSL.ZeroReturnError:
pass
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = eventlet.connect(sock.getsockname())
client = ssl.wrap_socket(raw_client)
client.sendall(b'X')
greenio.shutdown_safe(client)
client.close()
server_coro.wait()
def test_ssl_sending_messages(self):
s = eventlet.wrap_ssl(eventlet.listen(('localhost', 0)),
certfile=tests.certificate_file,
keyfile=tests.private_key_file,
server_side=True)
self.spawn_server(sock=s)
connect = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: %s:%s" % self.server_addr,
"Origin: http://%s:%s" % self.server_addr,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = eventlet.wrap_ssl(eventlet.connect(self.server_addr))
sock.sendall(six.b('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U'))
first_resp = b''
while b'\r\n\r\n' not in first_resp:
first_resp += sock.recv()
print('resp now:')
print(first_resp)
# make sure it sets the wss: protocol on the location header
loc_line = [
x for x in first_resp.split(b"\r\n")
if x.lower().startswith(b'sec-websocket-location')
][0]
expect_wss = ('wss://%s:%s' % self.server_addr).encode()
assert expect_wss in loc_line, "Expecting wss protocol in location: %s" % loc_line
sock.sendall(b'\x00hello\xFF')
result = sock.recv(1024)
self.assertEqual(result, b'\x00hello\xff')
sock.sendall(b'\x00start')
eventlet.sleep(0.001)
sock.sendall(b' end\xff')
result = sock.recv(1024)
self.assertEqual(result, b'\x00start end\xff')
greenio.shutdown_safe(sock)
sock.close()
eventlet.sleep(0.01)
def test_ssl_close(self):
def serve(listener):
sock, addr = listener.accept()
sock.recv(8192)
try:
self.assertEqual(b'', sock.recv(8192))
except greenio.SSL.ZeroReturnError:
pass
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = eventlet.connect(sock.getsockname())
client = ssl.wrap_socket(raw_client)
client.sendall(b'X')
greenio.shutdown_safe(client)
client.close()
server_coro.wait()
def test_ssl_close(self):
def serve(listener):
sock, addr = listener.accept()
stuff = sock.read(8192)
try:
self.assertEquals("", sock.read(8192))
except greenio.SSL.ZeroReturnError:
pass
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = eventlet.connect(('127.0.0.1', sock.getsockname()[1]))
client = util.wrap_ssl(raw_client)
client.write('X')
greenio.shutdown_safe(client)
client.close()
server_coro.wait()
def test_ssl_close(self):
def serve(listener):
sock, addr = listener.accept()
stuff = sock.read(8192)
try:
self.assertEquals("", sock.read(8192))
except greenio.SSL.ZeroReturnError:
pass
sock = listen_ssl_socket()
server_coro = eventlet.spawn(serve, sock)
raw_client = eventlet.connect(('127.0.0.1', sock.getsockname()[1]))
client = util.wrap_ssl(raw_client)
client.write('X')
greenio.shutdown_safe(client)
client.close()
server_coro.wait()
def test_ssl_sending_messages(self):
s = eventlet.wrap_ssl(
eventlet.listen(("localhost", 0)),
certfile=tests.certificate_file,
keyfile=tests.private_key_file,
server_side=True,
)
self.spawn_server(sock=s)
connect = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: %s:%s" % self.server_addr,
"Origin: http://%s:%s" % self.server_addr,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = eventlet.wrap_ssl(eventlet.connect(self.server_addr))
sock.sendall(six.b("\r\n".join(connect) + "\r\n\r\n^n:ds[4U"))
first_resp = b""
while b"\r\n\r\n" not in first_resp:
first_resp += sock.recv()
print("resp now:")
print(first_resp)
# make sure it sets the wss: protocol on the location header
loc_line = [x for x in first_resp.split(b"\r\n") if x.lower().startswith(b"sec-websocket-location")][0]
expect_wss = ("wss://%s:%s" % self.server_addr).encode()
assert expect_wss in loc_line, "Expecting wss protocol in location: %s" % loc_line
sock.sendall(b"\x00hello\xFF")
result = sock.recv(1024)
self.assertEqual(result, b"\x00hello\xff")
sock.sendall(b"\x00start")
eventlet.sleep(0.001)
sock.sendall(b" end\xff")
result = sock.recv(1024)
self.assertEqual(result, b"\x00start end\xff")
greenio.shutdown_safe(sock)
sock.close()
eventlet.sleep(0.01)
def test_ssl_sending_messages(self):
s = eventlet.wrap_ssl(eventlet.listen(('localhost', 0)),
certfile=certificate_file,
keyfile=private_key_file,
server_side=True)
self.spawn_server(sock=s)
connect = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = eventlet.wrap_ssl(eventlet.connect(('localhost', self.port)))
sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U')
first_resp = sock.recv(1024)
# make sure it sets the wss: protocol on the location header
loc_line = [
x for x in first_resp.split("\r\n")
if x.lower().startswith('sec-websocket-location')
][0]
self.assert_("wss://localhost" in loc_line,
"Expecting wss protocol in location: %s" % loc_line)
sock.sendall('\x00hello\xFF')
result = sock.recv(1024)
self.assertEqual(result, '\x00hello\xff')
sock.sendall('\x00start')
eventlet.sleep(0.001)
sock.sendall(' end\xff')
result = sock.recv(1024)
self.assertEqual(result, '\x00start end\xff')
greenio.shutdown_safe(sock)
sock.close()
eventlet.sleep(0.01)
def test_shutdown_safe(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.close()
# should not raise
greenio.shutdown_safe(sock)
return
else:
logger.notice('Started child %s' % pid)
children.append(pid)
try:
pid, status = os.wait()
if os.WIFEXITED(status) or os.WIFSIGNALED(status):
logger.error('Removing dead child %s' % pid)
children.remove(pid)
except OSError, err:
if err.errno not in (errno.EINTR, errno.ECHILD):
raise
except KeyboardInterrupt:
logger.notice('User quit')
break
greenio.shutdown_safe(sock)
sock.close()
logger.notice('Exited')
def make_pre_authed_request(env,
method,
path,
body=None,
headers=None,
agent='Chase'):
"""
Makes a new webob.Request based on the current env but with the
parameters specified. Note that this request will be preauthorized.
:param env: Current WSGI environment dictionary
def server(sock, site,
log=None,
environ=None,
max_size=None,
max_http_version=DEFAULT_MAX_HTTP_VERSION,
protocol=HttpProtocol,
server_event=None,
minimum_chunk_size=None,
log_x_forwarded_for=True,
custom_pool=None,
keepalive=True,
log_output=True,
log_format=DEFAULT_LOG_FORMAT,
url_length_limit=MAX_REQUEST_LINE,
debug=True,
socket_timeout=None,
capitalize_response_headers=True):
"""Start up a WSGI server handling requests from the supplied server
socket. This function loops forever. The *sock* object will be
closed after server exits, but the underlying file descriptor will
remain open, so if you have a dup() of *sock*, it will remain usable.
.. warning::
At the moment :func:`server` will always wait for active connections to finish before
exiting, even if there's an exception raised inside it
(*all* exceptions are handled the same way, including :class:`greenlet.GreenletExit`
and those inheriting from `BaseException`).
While this may not be an issue normally, when it comes to long running HTTP connections
(like :mod:`eventlet.websocket`) it will become problematic and calling
:meth:`~eventlet.greenthread.GreenThread.wait` on a thread that runs the server may hang,
even after using :meth:`~eventlet.greenthread.GreenThread.kill`, as long
as there are active connections.
:param sock: Server socket, must be already bound to a port and listening.
:param site: WSGI application function.
:param log: logging.Logger instance or file-like object that logs should be written to.
If a Logger instance is supplied, messages are sent to the INFO log level.
If not specified, sys.stderr is used.
:param environ: Additional parameters that go into the environ dictionary of every request.
:param max_size: Maximum number of client connections opened at any time by this server.
Default is 1024.
:param max_http_version: Set to "HTTP/1.0" to make the server pretend it only supports HTTP 1.0.
This can help with applications or clients that don't behave properly using HTTP 1.1.
:param protocol: Protocol class. Deprecated.
:param server_event: Used to collect the Server object. Deprecated.
:param minimum_chunk_size: Minimum size in bytes for http chunks. This can be used to improve
performance of applications which yield many small strings, though
using it technically violates the WSGI spec. This can be overridden
on a per request basis by setting environ['eventlet.minimum_write_chunk_size'].
:param log_x_forwarded_for: If True (the default), logs the contents of the x-forwarded-for
header in addition to the actual client ip address in the 'client_ip' field of the
log line.
:param custom_pool: A custom GreenPool instance which is used to spawn client green threads.
If this is supplied, max_size is ignored.
:param keepalive: If set to False, disables keepalives on the server; all connections will be
closed after serving one request.
:param log_output: A Boolean indicating if the server will log data or not.
:param log_format: A python format string that is used as the template to generate log lines.
The following values can be formatted into it: client_ip, date_time, request_line,
status_code, body_length, wall_seconds. The default is a good example of how to
use it.
:param url_length_limit: A maximum allowed length of the request url. If exceeded, 414 error
is returned.
:param debug: True if the server should send exception tracebacks to the clients on 500 errors.
If False, the server will respond with empty bodies.
:param socket_timeout: Timeout for client connections' socket operations. Default None means
wait forever.
:param capitalize_response_headers: Normalize response headers' names to Foo-Bar.
Default is True.
"""
serv = 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_output=log_output,
log_format=log_format,
url_length_limit=url_length_limit,
debug=debug,
socket_timeout=socket_timeout,
capitalize_response_headers=capitalize_response_headers,
)
if server_event is not None:
warnings.warn(
'eventlet.wsgi.Server() server_event kwarg is deprecated and will be removed soon',
DeprecationWarning, stacklevel=2)
server_event.send(serv)
if max_size is None:
max_size = DEFAULT_MAX_SIMULTANEOUS_REQUESTS
if custom_pool is not None:
pool = custom_pool
else:
pool = eventlet.GreenPool(max_size)
if not (hasattr(pool, 'spawn') and hasattr(pool, 'waitall')):
raise AttributeError('''\
eventlet.wsgi.Server pool must provide methods: `spawn`, `waitall`.
If unsure, use eventlet.GreenPool.''')
# [addr, socket, state]
connections = {}
def _clean_connection(_, conn):
connections.pop(conn[0], None)
conn[2] = STATE_CLOSE
greenio.shutdown_safe(conn[1])
conn[1].close()
try:
serv.log.info('({0}) wsgi starting up on {1}'.format(serv.pid, socket_repr(sock)))
while is_accepting:
try:
client_socket, client_addr = sock.accept()
client_socket.settimeout(serv.socket_timeout)
serv.log.debug('({0}) accepted {1!r}'.format(serv.pid, client_addr))
connections[client_addr] = connection = [client_addr, client_socket, STATE_IDLE]
(pool.spawn(serv.process_request, connection)
.link(_clean_connection, connection))
except ACCEPT_EXCEPTIONS as e:
if support.get_errno(e) not in ACCEPT_ERRNO:
raise
except (KeyboardInterrupt, SystemExit):
serv.log.info('wsgi exiting')
break
finally:
for cs in six.itervalues(connections):
prev_state = cs[2]
cs[2] = STATE_CLOSE
if prev_state == STATE_IDLE:
greenio.shutdown_safe(cs[1])
pool.waitall()
serv.log.info('({0}) wsgi exited, is_accepting={1}'.format(serv.pid, is_accepting))
try:
# NOTE: It's not clear whether we want this to leave the
# socket open or close it. Use cases like Spawning want
# the underlying fd to remain open, but if we're going
# that far we might as well not bother closing sock at
# all.
sock.close()
except socket.error as e:
if support.get_errno(e) not in BROKEN_SOCK:
traceback.print_exc()
length,
wfile=wfile,
wfile_line=wfile_line,
chunked_input=chunked)
env['eventlet.posthooks'] = []
return env
def finish(self):
try:
BaseHTTPServer.BaseHTTPRequestHandler.finish(self)
except socket.error, e:
# Broken pipe, connection reset by peer
if get_errno(e) not in BROKEN_SOCK:
raise
greenio.shutdown_safe(self.connection)
self.connection.close()
class Server(BaseHTTPServer.HTTPServer):
def __init__(self,
socket,
address,
app,
log=None,
environ=None,
max_http_version=None,
protocol=HttpProtocol,
minimum_chunk_size=None,
log_x_forwarded_for=True,
keepalive=True,
chunked = env.get('HTTP_TRANSFER_ENCODING', '').lower() == 'chunked'
env['wsgi.input'] = env['eventlet.input'] = Input(
self.rfile, length, wfile=wfile, wfile_line=wfile_line,
chunked_input=chunked)
env['eventlet.posthooks'] = []
return env
def finish(self):
try:
BaseHTTPServer.BaseHTTPRequestHandler.finish(self)
except socket.error, e:
# Broken pipe, connection reset by peer
if get_errno(e) not in BROKEN_SOCK:
raise
greenio.shutdown_safe(self.connection)
self.connection.close()
class Server(BaseHTTPServer.HTTPServer):
def __init__(self,
socket,
address,
app,
log=None,
environ=None,
max_http_version=None,
protocol=HttpProtocol,
minimum_chunk_size=None,
log_x_forwarded_for=True,
def run_wsgi(conf_path, app_section, *args, **kwargs):
"""
Runs the server using the specified number of workers.
:param conf_path: Path to paste.deploy style configuration file/directory
:param app_section: App name from conf file to load config from
:returns: 0 if successful, nonzero otherwise
"""
# Load configuration, Set logger and Load request processor
try:
(conf, logger, log_name) = \
_initrp(conf_path, app_section, *args, **kwargs)
except ConfigFileError as e:
print e
return 1
# bind to address and port
sock = get_socket(conf, default_port=kwargs.get('default_port', 8080))
# remaining tasks should not require elevated privileges
drop_privileges(conf.get('user', 'swift'))
# Ensure the configuration and application can be loaded before proceeding.
global_conf = {'log_name': log_name}
if 'global_conf_callback' in kwargs:
kwargs['global_conf_callback'](conf, global_conf)
loadapp(conf_path, global_conf=global_conf)
# set utils.FALLOCATE_RESERVE if desired
reserve = int(conf.get('fallocate_reserve', 0))
if reserve > 0:
utils.FALLOCATE_RESERVE = reserve
# redirect errors to logger and close stdio
capture_stdio(logger)
worker_count = config_auto_int_value(conf.get('workers'), CPU_COUNT)
# Useful for profiling [no forks].
if worker_count == 0:
run_server(conf, logger, sock, global_conf=global_conf)
return 0
def kill_children(*args):
"""Kills the entire process group."""
logger.error('SIGTERM received')
signal.signal(signal.SIGTERM, signal.SIG_IGN)
running[0] = False
os.killpg(0, signal.SIGTERM)
def hup(*args):
"""Shuts down the server, but allows running requests to complete"""
logger.error('SIGHUP received')
signal.signal(signal.SIGHUP, signal.SIG_IGN)
running[0] = False
running = [True]
signal.signal(signal.SIGTERM, kill_children)
signal.signal(signal.SIGHUP, hup)
children = []
while running[0]:
while len(children) < worker_count:
pid = os.fork()
if pid == 0:
signal.signal(signal.SIGHUP, signal.SIG_DFL)
signal.signal(signal.SIGTERM, signal.SIG_DFL)
run_server(conf, logger, sock)
logger.notice('Child %d exiting normally' % os.getpid())
return 0
else:
logger.notice('Started child %s' % pid)
children.append(pid)
try:
pid, status = os.wait()
if os.WIFEXITED(status) or os.WIFSIGNALED(status):
logger.error('Removing dead child %s' % pid)
children.remove(pid)
except OSError as err:
if err.errno not in (errno.EINTR, errno.ECHILD):
raise
except KeyboardInterrupt:
logger.notice('User quit')
break
greenio.shutdown_safe(sock)
sock.close()
logger.notice('Exited')
return 0
def finish(self):
BaseHTTPServer.BaseHTTPRequestHandler.finish(self)
greenio.shutdown_safe(self.connection)
self.connection.close()
def test_shutdown_safe(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.close()
# should not raise
greenio.shutdown_safe(sock)
def _clean_connection(_, conn):
connections.pop(conn[0], None)
conn[2] = STATE_CLOSE
greenio.shutdown_safe(conn[1])
conn[1].close()
def server(sock, site,
log=None,
environ=None,
max_size=None,
max_http_version=DEFAULT_MAX_HTTP_VERSION,
protocol=HttpProtocol,
server_event=None,
minimum_chunk_size=None,
log_x_forwarded_for=True,
custom_pool=None,
keepalive=True,
log_output=True,
log_format=DEFAULT_LOG_FORMAT,
url_length_limit=MAX_REQUEST_LINE,
debug=True,
socket_timeout=None,
capitalize_response_headers=True):
"""Start up a WSGI server handling requests from the supplied server
socket. This function loops forever. The *sock* object will be
closed after server exits, but the underlying file descriptor will
remain open, so if you have a dup() of *sock*, it will remain usable.
.. warning::
At the moment :func:`server` will always wait for active connections to finish before
exiting, even if there's an exception raised inside it
(*all* exceptions are handled the same way, including :class:`greenlet.GreenletExit`
and those inheriting from `BaseException`).
While this may not be an issue normally, when it comes to long running HTTP connections
(like :mod:`eventlet.websocket`) it will become problematic and calling
:meth:`~eventlet.greenthread.GreenThread.wait` on a thread that runs the server may hang,
even after using :meth:`~eventlet.greenthread.GreenThread.kill`, as long
as there are active connections.
:param sock: Server socket, must be already bound to a port and listening.
:param site: WSGI application function.
:param log: logging.Logger instance or file-like object that logs should be written to.
If a Logger instance is supplied, messages are sent to the INFO log level.
If not specified, sys.stderr is used.
:param environ: Additional parameters that go into the environ dictionary of every request.
:param max_size: Maximum number of client connections opened at any time by this server.
Default is 1024.
:param max_http_version: Set to "HTTP/1.0" to make the server pretend it only supports HTTP 1.0.
This can help with applications or clients that don't behave properly using HTTP 1.1.
:param protocol: Protocol class. Deprecated.
:param server_event: Used to collect the Server object. Deprecated.
:param minimum_chunk_size: Minimum size in bytes for http chunks. This can be used to improve
performance of applications which yield many small strings, though
using it technically violates the WSGI spec. This can be overridden
on a per request basis by setting environ['eventlet.minimum_write_chunk_size'].
:param log_x_forwarded_for: If True (the default), logs the contents of the x-forwarded-for
header in addition to the actual client ip address in the 'client_ip' field of the
log line.
:param custom_pool: A custom GreenPool instance which is used to spawn client green threads.
If this is supplied, max_size is ignored.
:param keepalive: If set to False, disables keepalives on the server; all connections will be
closed after serving one request.
:param log_output: A Boolean indicating if the server will log data or not.
:param log_format: A python format string that is used as the template to generate log lines.
The following values can be formatted into it: client_ip, date_time, request_line,
status_code, body_length, wall_seconds. The default is a good example of how to
use it.
:param url_length_limit: A maximum allowed length of the request url. If exceeded, 414 error
is returned.
:param debug: True if the server should send exception tracebacks to the clients on 500 errors.
If False, the server will respond with empty bodies.
:param socket_timeout: Timeout for client connections' socket operations. Default None means
wait forever.
:param capitalize_response_headers: Normalize response headers' names to Foo-Bar.
Default is True.
"""
serv = 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_output=log_output,
log_format=log_format,
url_length_limit=url_length_limit,
debug=debug,
socket_timeout=socket_timeout,
capitalize_response_headers=capitalize_response_headers,
)
if server_event is not None:
warnings.warn(
'eventlet.wsgi.Server() server_event kwarg is deprecated and will be removed soon',
DeprecationWarning, stacklevel=2)
server_event.send(serv)
if max_size is None:
max_size = DEFAULT_MAX_SIMULTANEOUS_REQUESTS
if custom_pool is not None:
pool = custom_pool
else:
pool = eventlet.GreenPool(max_size)
if not (hasattr(pool, 'spawn') and hasattr(pool, 'waitall')):
raise AttributeError('''\
eventlet.wsgi.Server pool must provide methods: `spawn`, `waitall`.
If unsure, use eventlet.GreenPool.''')
# [addr, socket, state]
connections = {}
def _clean_connection(_, conn):
connections.pop(conn[0], None)
conn[2] = STATE_CLOSE
greenio.shutdown_safe(conn[1])
conn[1].close()
try:
serv.log.info('({0}) wsgi starting up on {1}'.format(serv.pid, socket_repr(sock)))
while is_accepting:
try:
client_socket, client_addr = sock.accept()
client_socket.settimeout(serv.socket_timeout)
serv.log.debug('({0}) accepted {1!r}'.format(serv.pid, client_addr))
connections[client_addr] = connection = [client_addr, client_socket, STATE_IDLE]
(pool.spawn(serv.process_request, connection)
.link(_clean_connection, connection))
except ACCEPT_EXCEPTIONS as e:
if support.get_errno(e) not in ACCEPT_ERRNO:
raise
except (KeyboardInterrupt, SystemExit):
serv.log.info('wsgi exiting')
break
finally:
for cs in six.itervalues(connections):
prev_state = cs[2]
cs[2] = STATE_CLOSE
if prev_state == STATE_IDLE:
greenio.shutdown_safe(cs[1])
pool.waitall()
serv.log.info('({0}) wsgi exited, is_accepting={1}'.format(serv.pid, is_accepting))
try:
# NOTE: It's not clear whether we want this to leave the
# socket open or close it. Use cases like Spawning want
# the underlying fd to remain open, but if we're going
# that far we might as well not bother closing sock at
# all.
sock.close()
except socket.error as e:
if support.get_errno(e) not in BROKEN_SOCK:
traceback.print_exc()
def finish(self):
BaseHTTPServer.BaseHTTPRequestHandler.finish(self)
greenio.shutdown_safe(self.connection)
self.connection.close()
def _clean_connection(_, conn):
connections.pop(conn[0], None)
conn[2] = STATE_CLOSE
greenio.shutdown_safe(conn[1])
conn[1].close()
def run_wsgi(conf_path, app_section, *args, **kwargs):
"""
Runs the server using the specified number of workers.
:param conf_path: Path to paste.deploy style configuration file/directory
:param app_section: App name from conf file to load config from
:returns: 0 if successful, nonzero otherwise
"""
# Load configuration, Set logger and Load request processor
try:
(conf, logger, log_name) = \
_initrp(conf_path, app_section, *args, **kwargs)
except ConfigFileError as e:
print e
return 1
# bind to address and port
sock = get_socket(conf, default_port=kwargs.get('default_port', 8080))
# remaining tasks should not require elevated privileges
drop_privileges(conf.get('user', 'ubuntu'))
# Ensure the configuration and application can be loaded before proceeding.
global_conf = {'log_name': log_name}
if 'global_conf_callback' in kwargs:
kwargs['global_conf_callback'](conf, global_conf)
loadapp(conf_path, global_conf=global_conf)
# set utils.FALLOCATE_RESERVE if desired
reserve = int(conf.get('fallocate_reserve', 0))
if reserve > 0:
utils.FALLOCATE_RESERVE = reserve
# redirect errors to logger and close stdio
capture_stdio(logger)
worker_count = config_auto_int_value(conf.get('workers'), CPU_COUNT)
# Useful for profiling [no forks].
if worker_count == 0:
run_server(conf, logger, sock, global_conf=global_conf)
return 0
def kill_children(*args):
"""Kills the entire process group."""
logger.error('SIGTERM received')
signal.signal(signal.SIGTERM, signal.SIG_IGN)
running[0] = False
os.killpg(0, signal.SIGTERM)
def hup(*args):
"""Shuts down the server, but allows running requests to complete"""
logger.error('SIGHUP received')
signal.signal(signal.SIGHUP, signal.SIG_IGN)
running[0] = False
running = [True]
signal.signal(signal.SIGTERM, kill_children)
signal.signal(signal.SIGHUP, hup)
children = []
while running[0]:
while len(children) < worker_count:
pid = os.fork()
if pid == 0:
signal.signal(signal.SIGHUP, signal.SIG_DFL)
signal.signal(signal.SIGTERM, signal.SIG_DFL)
#with open("/home/ubuntu/transition_statistics.txt", "a") as tran_file:
# tran_file.write("ESTOU NO FORK!!!\n")
oracle_plus.get_oracle_plus().set_attributes(len(children))
oracle.get_oracle().set_attributes(int(conf.get('number_of_replicas', 3)),
float(conf.get('average_window_size', 10)),
config_true_value(conf.get('use_adaptation', True)),
int(conf.get('initial_write_quorum_size', 2)),
int(conf.get('initial_read_quorum_size', 2)),
conf.get('oracle_log_file', '/home/ubuntu/oracle.txt'),
conf.get('oracle_lib_path', '/home/ubuntu/oracle_files/oracle_twitter'),
conf.get('oracle_model_path', '/home/ubuntu/oracle_files/oracle_twitter'),
conf.get('ip', ''),
int(conf.get('port', '')),
conf.get('master_ip', ''),
conf.get('slave_ips', ''),
int(conf.get('replica_reconciliation_timeout', 2)),
len(children),
worker_count)
run_server(conf, logger, sock)
logger.notice('Child %d exiting normally' % os.getpid())
return 0
else:
logger.notice('Started child %s' % pid)
children.append(pid)
try:
pid, status = os.wait()
if os.WIFEXITED(status) or os.WIFSIGNALED(status):
logger.error('Removing dead child %s' % pid)
children.remove(pid)
except OSError as err:
if err.errno not in (errno.EINTR, errno.ECHILD):
raise
except KeyboardInterrupt:
logger.notice('User quit')
break
greenio.shutdown_safe(sock)
sock.close()
logger.notice('Exited')
return 0
def serve(listener):
sock, addr = listener.accept()
sock.write('content')
greenio.shutdown_safe(sock)
sock.close()
def serve(listener):
sock, addr = listener.accept()
sock.write('content')
greenio.shutdown_safe(sock)
sock.close()
return
else:
logger.notice("Started child %s" % pid)
children.append(pid)
try:
pid, status = os.wait()
if os.WIFEXITED(status) or os.WIFSIGNALED(status):
logger.error("Removing dead child %s" % pid)
children.remove(pid)
except OSError, err:
if err.errno not in (errno.EINTR, errno.ECHILD):
raise
except KeyboardInterrupt:
logger.notice("User quit")
break
greenio.shutdown_safe(sock)
sock.close()
logger.notice("Exited")
def make_pre_authed_request(env, method, path, body=None, headers=None, agent="Swift"):
"""
Makes a new webob.Request based on the current env but with the
parameters specified. Note that this request will be preauthorized.
:param env: Current WSGI environment dictionary
:param method: HTTP method of new request
:param path: HTTP path of new request
:param body: HTTP body of new request; None by default
:param headers: Extra HTTP headers of new request; None by default
def run_wsgi(conf_path, app_section, *args, **kwargs):
"""
Runs the server using the specified number of workers.
:param conf_path: Path to paste.deploy style configuration file/directory
:param app_section: App name from conf file to load config from
:returns: 0 if successful, nonzero otherwise
"""
# Load configuration, Set logger and Load request processor
try:
(conf, logger, log_name) = _initrp(conf_path, app_section, *args, **kwargs)
except ConfigFileError as e:
print e
return 1
# bind to address and port
sock = get_socket(conf, default_port=kwargs.get("default_port", 8080))
# remaining tasks should not require elevated privileges
drop_privileges(conf.get("user", "swift"))
# Ensure the configuration and application can be loaded before proceeding.
global_conf = {"log_name": log_name}
if "global_conf_callback" in kwargs:
kwargs["global_conf_callback"](conf, global_conf)
loadapp(conf_path, global_conf=global_conf)
# set utils.FALLOCATE_RESERVE if desired
reserve = int(conf.get("fallocate_reserve", 0))
if reserve > 0:
utils.FALLOCATE_RESERVE = reserve
# redirect errors to logger and close stdio
capture_stdio(logger)
worker_count = config_auto_int_value(conf.get("workers"), CPU_COUNT)
# Useful for profiling [no forks].
if worker_count == 0:
run_server(conf, logger, sock, global_conf=global_conf)
return 0
def kill_children(*args):
"""Kills the entire process group."""
logger.error("SIGTERM received")
signal.signal(signal.SIGTERM, signal.SIG_IGN)
running[0] = False
os.killpg(0, signal.SIGTERM)
def hup(*args):
"""Shuts down the server, but allows running requests to complete"""
logger.error("SIGHUP received")
signal.signal(signal.SIGHUP, signal.SIG_IGN)
running[0] = False
running = [True]
signal.signal(signal.SIGTERM, kill_children)
signal.signal(signal.SIGHUP, hup)
children = []
while running[0]:
while len(children) < worker_count:
pid = os.fork()
if pid == 0:
signal.signal(signal.SIGHUP, signal.SIG_DFL)
signal.signal(signal.SIGTERM, signal.SIG_DFL)
run_server(conf, logger, sock)
logger.notice("Child %d exiting normally" % os.getpid())
return 0
else:
logger.notice("Started child %s" % pid)
children.append(pid)
try:
pid, status = os.wait()
if os.WIFEXITED(status) or os.WIFSIGNALED(status):
logger.error("Removing dead child %s" % pid)
children.remove(pid)
except OSError as err:
if err.errno not in (errno.EINTR, errno.ECHILD):
raise
except KeyboardInterrupt:
logger.notice("User quit")
break
greenio.shutdown_safe(sock)
sock.close()
logger.notice("Exited")
return 0
def run_wsgi(conf_path, app_section, *args, **kwargs):
"""
Runs the server using the specified number of workers.
:param conf_path: Path to paste.deploy style configuration file/directory
:param app_section: App name from conf file to load config from
:returns: 0 if successful, nonzero otherwise
"""
# Load configuration, Set logger and Load request processor
try:
(conf, logger, log_name) = \
_initrp(conf_path, app_section, *args, **kwargs)
except ConfigFileError as e:
print(e)
return 1
print('conf,logger,log_name',conf,logger,log_name)
# bind to address and port
try:
sock = get_socket(conf)
except ConfigFilePortError:
msg = 'bind_port wasn\'t properly set in the config file. ' \
'It must be explicitly set to a valid port number.'
logger.error(msg)
print(msg)
return 1
print('sock',sock)
# remaining tasks should not require elevated privileges
drop_privileges(conf.get('user', 'swift'))
# Ensure the configuration and application can be loaded before proceeding.
global_conf = {'log_name': log_name}
if 'global_conf_callback' in kwargs:
kwargs['global_conf_callback'](conf, global_conf)
print('**** calling loadapp function start *****')
#loadapp(conf_path, global_conf=global_conf)
print('**** calling loadapp function end *****')
# set utils.FALLOCATE_RESERVE if desired
reserve = int(conf.get('fallocate_reserve', 0))
print('reserve',reserve)
if reserve > 0:
utils.FALLOCATE_RESERVE = reserve
# redirect errors to logger and close stdio
capture_stdio(logger)
print('capture_studio done')
worker_count = config_auto_int_value(conf.get('workers'), CPU_COUNT)
print('worker_count',worker_count)
# Useful for profiling [no forks].
if worker_count == 0:
run_server(conf, logger, sock, global_conf=global_conf)
print('run_server when worker_count is 0')
return 0
def kill_children(*args):
"""Kills the entire process group."""
logger.error('SIGTERM received')
signal.signal(signal.SIGTERM, signal.SIG_IGN)
running[0] = False
os.killpg(0, signal.SIGTERM)
def hup(*args):
"""Shuts down the server, but allows running requests to complete"""
logger.error('SIGHUP received')
signal.signal(signal.SIGHUP, signal.SIG_IGN)
running[0] = False
running = [True]
signal.signal(signal.SIGTERM, kill_children)
signal.signal(signal.SIGHUP, hup)
children = []
while running[0]:
while len(children) < worker_count:
pid = os.fork()
print('pid',pid)
if pid == 0:
signal.signal(signal.SIGHUP, signal.SIG_DFL)
signal.signal(signal.SIGTERM, signal.SIG_DFL)
print('')
print('in run_wsgi now calling run_server,conf,logger,sock',conf,logger,sock)
print('')
run_server(conf, logger, sock)
logger.notice('Child %d exiting normally' % os.getpid())
return 0
else:
logger.notice('Started child %s' % pid)
children.append(pid)
try:
pid, status = os.wait()
if os.WIFEXITED(status) or os.WIFSIGNALED(status):
logger.error('Removing dead child %s' % pid)
children.remove(pid)
except OSError as err:
if err.errno not in (errno.EINTR, errno.ECHILD):
raise
except KeyboardInterrupt:
logger.notice('User quit')
break
greenio.shutdown_safe(sock)
sock.close()
logger.notice('Exited')
return 0