mirror of
https://github.com/frappe/gunicorn.git
synced 2026-01-14 11:09:11 +08:00
12ec996d54
When the application starts yielding a body and then raises an error, we should immediately close the connection to the client to indicate the error.
120 lines
4.2 KiB
Python
120 lines
4.2 KiB
Python
# -*- coding: utf-8 -
|
|
#
|
|
# This file is part of gunicorn released under the MIT license.
|
|
# See the NOTICE for more information.
|
|
|
|
from datetime import datetime
|
|
import errno
|
|
import socket
|
|
import ssl
|
|
|
|
import gunicorn.http as http
|
|
import gunicorn.http.wsgi as wsgi
|
|
import gunicorn.util as util
|
|
import gunicorn.workers.base as base
|
|
from gunicorn import six
|
|
|
|
ALREADY_HANDLED = object()
|
|
|
|
|
|
class AsyncWorker(base.Worker):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(AsyncWorker, self).__init__(*args, **kwargs)
|
|
self.worker_connections = self.cfg.worker_connections
|
|
|
|
def timeout_ctx(self):
|
|
raise NotImplementedError()
|
|
|
|
def handle(self, listener, client, addr):
|
|
req = None
|
|
try:
|
|
parser = http.RequestParser(self.cfg, client)
|
|
try:
|
|
if not self.cfg.keepalive:
|
|
req = six.next(parser)
|
|
self.handle_request(listener, req, client, addr)
|
|
else:
|
|
# keepalive loop
|
|
while True:
|
|
req = None
|
|
with self.timeout_ctx():
|
|
req = six.next(parser)
|
|
if not req:
|
|
break
|
|
self.handle_request(listener, req, client, addr)
|
|
except http.errors.NoMoreData as e:
|
|
self.log.debug("Ignored premature client disconnection. %s", e)
|
|
except StopIteration as e:
|
|
self.log.debug("Closing connection. %s", e)
|
|
except ssl.SSLError:
|
|
raise # pass to next try-except level
|
|
except socket.error:
|
|
raise # pass to next try-except level
|
|
except Exception as e:
|
|
self.handle_error(req, client, addr, e)
|
|
except ssl.SSLError as e:
|
|
if e.args[0] == ssl.SSL_ERROR_EOF:
|
|
self.log.debug("ssl connection closed")
|
|
client.close()
|
|
else:
|
|
self.log.debug("Error processing SSL request.")
|
|
self.handle_error(req, client, addr, e)
|
|
except socket.error as e:
|
|
if e.args[0] not in (errno.EPIPE, errno.ECONNRESET):
|
|
self.log.exception("Socket error processing request.")
|
|
else:
|
|
if e.args[0] == errno.ECONNRESET:
|
|
self.log.debug("Ignoring connection reset")
|
|
else:
|
|
self.log.debug("Ignoring EPIPE")
|
|
except Exception as e:
|
|
self.handle_error(req, client, addr, e)
|
|
finally:
|
|
util.close(client)
|
|
|
|
def handle_request(self, listener, req, sock, addr):
|
|
request_start = datetime.now()
|
|
environ = {}
|
|
resp = None
|
|
try:
|
|
self.cfg.pre_request(self, req)
|
|
resp, environ = wsgi.create(req, sock, addr,
|
|
listener.getsockname(), self.cfg)
|
|
self.nr += 1
|
|
if self.alive and self.nr >= self.max_requests:
|
|
self.log.info("Autorestarting worker after current request.")
|
|
resp.force_close()
|
|
self.alive = False
|
|
|
|
if not self.cfg.keepalive:
|
|
resp.force_close()
|
|
|
|
respiter = self.wsgi(environ, resp.start_response)
|
|
if respiter == ALREADY_HANDLED:
|
|
return False
|
|
try:
|
|
for item in respiter:
|
|
resp.write(item)
|
|
resp.close()
|
|
request_time = datetime.now() - request_start
|
|
self.log.access(resp, req, environ, request_time)
|
|
finally:
|
|
if hasattr(respiter, "close"):
|
|
respiter.close()
|
|
if resp.should_close():
|
|
raise StopIteration()
|
|
except Exception:
|
|
if resp.headers_sent:
|
|
# If the requests have already been sent, we should close the
|
|
# connection to indicate the error.
|
|
sock.shutdown(socket.SHUT_RDWR)
|
|
sock.close()
|
|
raise
|
|
finally:
|
|
try:
|
|
self.cfg.post_request(self, req, environ, resp)
|
|
except Exception:
|
|
self.log.exception("Exception in post_request hook")
|
|
return True
|