def monkeypatch_wsgiref_on_windows():
"""
On windows Django live test cases have the bad habbit of spewing Error 10045 into the console.
This monkeypatch makes wsgiref's server (used in live test cases) handle 10045 properly.
"""
if platform.system() != "Windows":
return
import socket
from wsgiref.simple_server import ServerHandler, WSGIRequestHandler
def monkeypatch_handle(self):
"""Handle a single HTTP request"""
try:
self.raw_requestline = self.rfile.readline()
except socket.error, err:
if err.errno == 10054:
return
else:
raise
if not self.parse_request(): # An error code has been sent, just exit
return
handler = ServerHandler(self.rfile, self.wfile, self.get_stderr(),
self.get_environ())
handler.request_handler = self # backpointer for logging
handler.run(self.server.get_app())
def monkeypatch_wsgiref_on_windows():
"""
On windows Django live test cases have the bad habbit of spewing Error 10045 into the console.
This monkeypatch makes wsgiref's server (used in live test cases) handle 10045 properly.
"""
if platform.system() != "Windows":
return
import socket
from wsgiref.simple_server import ServerHandler, WSGIRequestHandler
def monkeypatch_handle(self):
"""Handle a single HTTP request"""
try:
self.raw_requestline = self.rfile.readline()
except socket.error, err:
if err.errno == 10054:
return
else:
raise
if not self.parse_request(): # An error code has been sent, just exit
return
handler = ServerHandler(self.rfile, self.wfile, self.get_stderr(), self.get_environ())
handler.request_handler = self # backpointer for logging
handler.run(self.server.get_app())
def handle(self):
"""Handle a single HTTP request"""
self.raw_requestline = self.rfile.readline(65537)
if len(self.raw_requestline) > 65536:
self.requestline = ''
self.request_version = ''
self.command = ''
self.send_error(414)
return
if not self.parse_request(): # An error code has been sent, just exit
return
handler = ServerHandler(
self.rfile,
self.wfile,
self.get_stderr(),
self.get_environ(),
multithread=False,
multiprocess=False,
)
handler.request_handler = self # backpointer for logging
handler.run(self.server.get_app())
def run(self, application):
"""ServerHandler.run, then log the request when broken pipe"""
try:
ServerHandler.run(self, application)
finally:
if self.status: # when broken pipe
self.request_handler.log_request(
self.status.split(' ', 1)[0], self.bytes_sent)
def finish_response(self):
try:
ServerHandler.finish_response(self)
except IOError as ex:
if ex.errno == 32:
print('client disconnected.')
else:
raise ex
def handle_error(self):
"""Catch errors that occur when serializing the return value to HTTP response and report fault"""
# There is a bug in some versions of wsgi where code here fails because status is None or environ is None
self.environ = self.environ or {'SERVER_PROTOCOL': 'HTTP/1.0'}
self.status = self.status or "500 Internal server error"
exc_type, exc_value, exc_traceback = sys.exc_info()
trace = traceback.format_list(traceback.extract_tb(exc_traceback))
self.fault = FaultData("Unable to convert result into http response",
exc_value, trace)
ServerHandler.handle_error(self)
def finish_response(self):
# If the browser closes the connection while we still want to sen stuff back,
# we want to fail silently and give up. This often happens in tests where the
# browser may want to request embedded links (like stylesheets) too, yet the
# test has already clicked on the next link.
ssl_eof_error = ssl.SSLEOFError
broken_pipe_error = BrokenPipeError
try:
ServerHandler.finish_response(self)
except (ssl_eof_error, broken_pipe_error):
# Silently ignore it if it looks like the client browser closed the connection.
pass
def handle(self):
self.raw_requestline = self.rfile.readline()
if not self.parse_request(): # An error code has been sent, just exit
return
if SimpleXMLRPCRequestHandler.is_rpc_path_valid(self):
# @CTB hack hack hack, I should be ashamed of myself.
global client_ip
client_ip = self.client_address[0]
return SimpleXMLRPCRequestHandler.do_POST(self)
handler = ServerHandler(
self.rfile, self.wfile, self.get_stderr(), self.get_environ(),
multithread=False, multiprocess=False
)
handler.request_handler = self # backpointer for logging
handler.run(self.server.get_app())
def _handle(self):
"""
Handle:
/xmlrpc => SimpleXMLRPCServer
/upload => self._handle_upload
all else => WSGI app for Web UI
"""
self.raw_requestline = self.rfile.readline()
if not self.parse_request(): # An error code has been sent, just exit
return
print "SERVER HANDLE: path is '%s'" % self.path
content_length = self.headers.getheader('content-length')
if not content_length:
content_length = 0
content_length = int(content_length)
print 'content length is:', content_length
if content_length > self.MAX_CONTENT_LENGTH:
message = "403 FORBIDDEN: You're trying to upload %d bytes; we only allow %d per request." % (content_length, self.MAX_CONTENT_LENGTH)
self._send_html_response(403, message)
return
if SimpleXMLRPCRequestHandler.is_rpc_path_valid(self):
# @CTB hack hack hack, I should be ashamed of myself.
global client_ip
client_ip = self.client_address[0]
return SimpleXMLRPCRequestHandler.do_POST(self)
elif self.path.startswith('/upload?'):
return self._handle_upload()
elif self.path.startswith('/notify'):
return self._handle_notify()
## else:
handler = ServerHandler(
self.rfile, self.wfile, self.get_stderr(), self.get_environ(),
multithread=False, multiprocess=False
)
handler.request_handler = self # backpointer for logging
handler.run(self.server.get_app())
def handle(self):
"""
Handle:
/xmlrpc => SimpleXMLRPCServer
/upload => self._handle_upload
/notify => self._handle_notify
all else => WSGI app for Web UI
"""
self.raw_requestline = self.rfile.readline()
if not self.parse_request(): # An error code has been sent, just exit
return
content_length = self.headers.getheader('content-length')
if not content_length:
content_length = 0
content_length = int(content_length)
print 'content length is:', content_length
if content_length > self.MAX_CONTENT_LENGTH:
message = too_big_message % (content_length,
self.MAX_CONTENT_LENGTH)
self._send_html_response(403, message)
return
if SimpleXMLRPCRequestHandler.is_rpc_path_valid(self):
return SimpleXMLRPCRequestHandler.do_POST(self)
elif self.path.startswith('/upload?'):
return self._handle_upload()
elif self.path.startswith('/notify'):
return self._handle_notify()
## else:
handler = ServerHandler(
self.rfile, self.wfile, self.get_stderr(), self.get_environ(),
multithread=False, multiprocess=False
)
handler.request_handler = self # backpointer for logging
handler.run(self.server.get_app())
def handle_single(self):
"""Handle a single HTTP request"""
self.raw_requestline = self.rfile.readline(65537)
if len(self.raw_requestline) > 65536:
self.requestline = ''
self.request_version = ''
self.command = ''
self.close_connection = 1
self.send_error(414)
return
if not self.parse_request(): # An error code has been sent, just exit
return
handler = ServerHandler(self.rfile, self.wfile, self.get_stderr(),
self.get_environ())
handler.http_version = "1.1"
handler.request_handler = self # backpointer for logging
# eNodeB will sometimes close connection to enodebd.
# The cause of this is unknown, but we can safely ignore the
# closed connection, and continue as normal otherwise.
#
# While this throws a BrokenPipe exception in wsgi server,
# it also causes an AttributeError to be raised because of a
# bug in the wsgi server.
# https://bugs.python.org/issue27682
try:
handler.run(self.server.get_app())
except BrokenPipeError:
self.log_error(
"eNodeB has unexpectedly closed the TCP connection.")
def handle(self):
"""
Handle:
/xmlrpc => SimpleXMLRPCServer
/upload => self._handle_upload
all else => WSGI app for Web UI
"""
self.raw_requestline = self.rfile.readline()
if not self.parse_request(): # An error code has been sent, just exit
return
content_length = self.headers.getheader('content-length')
if not content_length:
content_length = 0
content_length = int(content_length)
print 'content length is:', content_length
if content_length > self.MAX_CONTENT_LENGTH:
message = too_big_message % (content_length,
self.MAX_CONTENT_LENGTH)
self._send_html_response(403, message)
return
if SimpleXMLRPCRequestHandler.is_rpc_path_valid(self):
return SimpleXMLRPCRequestHandler.do_POST(self)
elif self.path.startswith('/upload?'):
return self._handle_upload()
## else:
handler = ServerHandler(
self.rfile, self.wfile, self.get_stderr(), self.get_environ(),
multithread=False, multiprocess=False
)
handler.request_handler = self # backpointer for logging
handler.run(self.server.get_app())
def handle_write(self):
self._can_write = False
handler = ServerHandler(self._input_stream, self.wfile,
self.get_stderr(), self.get_environ())
handler.server_software = self.server_version
handler.http_version = self.protocol_version[5:]
handler.request_handler = self # backpointer for logging
handler.wsgi_multiprocess = False
handler.wsgi_multithread = False
try:
handler.run(self.server.get_app())
except Exception:
self.handle_error()
return
if self.close_connection:
self.handle_close()
else:
try:
self.wfile.flush()
except socket.error:
self.handle_error()
else:
self._can_read = True
def __init__(self, *args, **kwargs):
ServerHandler.__init__(self, *args, **kwargs)
self.iterator = None
def close(self):
# There is a bug in some versions of wsgi where code here fails because status is None or environ is None
self.environ = self.environ or {'SERVER_PROTOCOL': 'HTTP/1.0'}
self.status = self.status or "500 Internal server error"
ServerHandler.close(self)
def log_exception(self, exc_info):
import errno
if exc_info[1].args[0] == errno.EPIPE:
return # don't log broken pipes
ServerHandler.log_exception(self, exc_info) # log other
def log_exception(self, exc_info):
if not should_ignore(exc_info):
ServerHandler.log_exception(self, exc_info)
def log_exception(self, exc_info):
if not should_ignore(exc_info):
ServerHandler.log_exception(self, exc_info)
def setup_environ(self):
ServerHandler.setup_environ(self)
