166 lines
5.0 KiB
Python
166 lines
5.0 KiB
Python
"""BaseHTTPServer that implements the Python WSGI protocol (PEP 3333)
|
|
|
|
This is both an example of how WSGI can be implemented, and a basis for running
|
|
simple web applications on a local machine, such as might be done when testing
|
|
or debugging an application. It has not been reviewed for security issues,
|
|
however, and we strongly recommend that you use a "real" web server for
|
|
production use.
|
|
|
|
For example usage, see the 'if __name__=="__main__"' block at the end of the
|
|
module. See also the BaseHTTPServer module docs for other API information.
|
|
"""
|
|
|
|
from http.server import BaseHTTPRequestHandler, HTTPServer
|
|
import sys
|
|
import urllib.parse
|
|
from wsgiref.handlers import SimpleHandler
|
|
from platform import python_implementation
|
|
|
|
__version__ = "0.2"
|
|
__all__ = ['WSGIServer', 'WSGIRequestHandler', 'demo_app', 'make_server']
|
|
|
|
|
|
server_version = "WSGIServer/" + __version__
|
|
sys_version = python_implementation() + "/" + sys.version.split()[0]
|
|
software_version = server_version + ' ' + sys_version
|
|
|
|
|
|
class ServerHandler(SimpleHandler):
|
|
|
|
server_software = software_version
|
|
|
|
def close(self):
|
|
try:
|
|
self.request_handler.log_request(
|
|
self.status.split(' ',1)[0], self.bytes_sent
|
|
)
|
|
finally:
|
|
SimpleHandler.close(self)
|
|
|
|
|
|
|
|
class WSGIServer(HTTPServer):
|
|
|
|
"""BaseHTTPServer that implements the Python WSGI protocol"""
|
|
|
|
application = None
|
|
|
|
def server_bind(self):
|
|
"""Override server_bind to store the server name."""
|
|
HTTPServer.server_bind(self)
|
|
self.setup_environ()
|
|
|
|
def setup_environ(self):
|
|
# Set up base environment
|
|
env = self.base_environ = {}
|
|
env['SERVER_NAME'] = self.server_name
|
|
env['GATEWAY_INTERFACE'] = 'CGI/1.1'
|
|
env['SERVER_PORT'] = str(self.server_port)
|
|
env['REMOTE_HOST']=''
|
|
env['CONTENT_LENGTH']=''
|
|
env['SCRIPT_NAME'] = ''
|
|
|
|
def get_app(self):
|
|
return self.application
|
|
|
|
def set_app(self,application):
|
|
self.application = application
|
|
|
|
|
|
|
|
class WSGIRequestHandler(BaseHTTPRequestHandler):
|
|
|
|
server_version = "WSGIServer/" + __version__
|
|
|
|
def get_environ(self):
|
|
env = self.server.base_environ.copy()
|
|
env['SERVER_PROTOCOL'] = self.request_version
|
|
env['SERVER_SOFTWARE'] = self.server_version
|
|
env['REQUEST_METHOD'] = self.command
|
|
if '?' in self.path:
|
|
path,query = self.path.split('?',1)
|
|
else:
|
|
path,query = self.path,''
|
|
|
|
env['PATH_INFO'] = urllib.parse.unquote(path, 'iso-8859-1')
|
|
env['QUERY_STRING'] = query
|
|
|
|
host = self.address_string()
|
|
if host != self.client_address[0]:
|
|
env['REMOTE_HOST'] = host
|
|
env['REMOTE_ADDR'] = self.client_address[0]
|
|
|
|
if self.headers.get('content-type') is None:
|
|
env['CONTENT_TYPE'] = self.headers.get_content_type()
|
|
else:
|
|
env['CONTENT_TYPE'] = self.headers['content-type']
|
|
|
|
length = self.headers.get('content-length')
|
|
if length:
|
|
env['CONTENT_LENGTH'] = length
|
|
|
|
for k, v in self.headers.items():
|
|
k=k.replace('-','_').upper(); v=v.strip()
|
|
if k in env:
|
|
continue # skip content length, type,etc.
|
|
if 'HTTP_'+k in env:
|
|
env['HTTP_'+k] += ','+v # comma-separate multiple headers
|
|
else:
|
|
env['HTTP_'+k] = v
|
|
return env
|
|
|
|
def get_stderr(self):
|
|
return sys.stderr
|
|
|
|
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,
|
|
)
|
|
handler.request_handler = self # backpointer for logging
|
|
handler.run(self.server.get_app())
|
|
|
|
|
|
|
|
def demo_app(environ,start_response):
|
|
from io import StringIO
|
|
stdout = StringIO()
|
|
print("Hello world!", file=stdout)
|
|
print(file=stdout)
|
|
h = sorted(environ.items())
|
|
for k,v in h:
|
|
print(k,'=',repr(v), file=stdout)
|
|
start_response("200 OK", [('Content-Type','text/plain; charset=utf-8')])
|
|
return [stdout.getvalue().encode("utf-8")]
|
|
|
|
|
|
def make_server(
|
|
host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler
|
|
):
|
|
"""Create a new WSGI server listening on `host` and `port` for `app`"""
|
|
server = server_class((host, port), handler_class)
|
|
server.set_app(app)
|
|
return server
|
|
|
|
|
|
if __name__ == '__main__':
|
|
with make_server('', 8000, demo_app) as httpd:
|
|
sa = httpd.socket.getsockname()
|
|
print("Serving HTTP on", sa[0], "port", sa[1], "...")
|
|
import webbrowser
|
|
webbrowser.open('http://localhost:8000/xyz?abc')
|
|
httpd.handle_request() # serve one request, then exit
|