#! /usr/bin/env python
"""Provide simple support for Java-style servlets.
The code in this module provides an incomplete port of Java's API for
servlets. Only essential classes and methods are implemented here."""
################################################################################
__author__ = 'Stephen "Zero" Chappell <Noctis.Skytower@gmail.com>'
__date__ = '11 February 2010'
__version__ = '$Revision: 3 $'
################################################################################
import urllib.parse
import socketserver
import http.server
import webbrowser
import socket
import cgitb
import cgi
import sys
import io
################################################################################
class HttpServlet(http.server.BaseHTTPRequestHandler):
"""Provide a base class for implementing a servlet.
The HttpServlet class should be inherited by any class that is to be
run as a servlet. A few basic HTTP methods are automatically handled
by this class and passed on to the service method to be written by
the servlet designer. Request and response systems are handled here."""
# These variables properly identify and setup the handler.
server_version = 'HttpServlet/' + http.server.__version__
protocol_version = 'HTTP/1.1'
__debug = False # Determines how exceptions are reported.
@classmethod
def debug(cls, value):
"""Set the debugging status of servlet applications.
This determines what happens when code raises an exception.
if True: traceback is sent back to the browser for analysis.
if False: the browser receives an ambiguous 500 error code."""
cls.__debug = value
def do_GET(self):
"""Handle the GET method sent via HTTP."""
if self.path == '/favicon.ico':
self.send_error(404)
return
self.__call_service(self.path)
def do_POST(self):
"""Handle the POST method sent via HTTP."""
try:
length = int(self.headers.get('content-length'))
except:
self.send_error(411)
else:
self.__call_service('?' + self.rfile.read(length).decode())
def __call_service(self, query):
"""Execute service method implemented by child class.
When either a GET or POST request is received, this method is
called with a string representing the query. Request and response
objects are created for the child's service method, and an answer
is sent back to the client with errors automatically being caught."""
request = _HttpServletRequest(query)
response = _HttpServletResponse()
try:
self.service(request, response)
except Exception:
if self.__debug:
self.send_response(500)
self.send_header('Content-Type', 'text/html')
self.send_header('Connection', 'close')
self.end_headers()
klass, value, trace = sys.exc_info()
# The next function call may raise an exception.
html = cgitb.html((klass, value, trace.tb_next))
self.wfile.write(html.encode())
else:
self.send_error(500)
else:
response_value = response._value
self.send_response(200)
self.send_header('Content-Type', response._type)
self.send_header('Content-Length', str(len(response_value)))
self.end_headers()
self.wfile.write(response_value)
def service(self, request, response):
"""Process the client's request and send back a response."""
raise NotImplementedError()
################################################################################
class _HttpServletRequest:
"""Store the query from the client's request.
Instances of this class are automatically created
to store query variables obtained by parsing the
path or post data sent from the client to the servlet."""
def __init__(self, path):
"""Initialize the request object from the path."""
query = urllib.parse.urlparse(path).query
self.__dict = urllib.parse.parse_qs(query, True)
def getParameter(self, name):
"""Compute the value of the named parameter.
The parameter that has the specified name is found,
and the first value associated with that name is
returned. If the name cannot be found, then None
is returned to the caller instead of an exception."""
return self.__dict.get(name, [None])[0]
################################################################################
class _HttpServletResponse:
"""Allow servlet to send response to client.
Servlet child classes have their service methods called with an
instance of this class. It allows the responses to be configured
for both the type of data and the content of the data being sent."""
def __init__(self):
"""Initialize a blank, generic response object."""
self.__content_type = 'text/plain'
self.__print_writer = _PrintWriter()
def setContentType(self, content_type):
"""Set the type of data being sent to client.
This is the argument to the "Content-Type" header sent to
the client. By default, it is set to "text/plain" but may
be set to whatever is appropriate for the data type being
sent. Note the data alterations in the _value property."""
self.__content_type = content_type
def getWriter(self):
"""Produce a writer object for printing.
This method returns a PrintWriter object that caches the
servlet's response to the client. Once the service method
returns, the PrintWriter's value is sent back to the client."""
return self.__print_writer
@property
def _type(self):
"""Read-only content-type property for __call_service."""
return self.__content_type
@property
def _value(self):
"""Read-only response-value property for __call_service."""
value = self.__print_writer.getvalue()
lines = value.replace('\r\n', '\n').replace('\r', '\n')
return lines.replace('\n', '\r\n').encode()
################################################################################
class _PrintWriter(io.StringIO):
"""Cache the response generated for the client.
An instance of the class is automatically built by HTTP Servlet
Response objects to cache the data being sent back to the client."""
print = io.StringIO.write
def println(self, string):
"""Print a line of data to the internal representation."""
self.write(string + '\r\n')
################################################################################
class HttpServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
"""Create a server with specified address and handler.
A generic web server can be instantiated with this class. It will listen
on the address given to its constructor and will use the handler class
to process all incoming traffic. Running a server is greatly simplified."""
# We should not be binding to an
# address that is already in use.
allow_reuse_address = False
@classmethod
def main(cls, RequestHandlerClass, port=80):
"""Start server with handler on given port.
This static method provides an easy way to start, run, and exit
a HttpServer instance. The server will be executed if possible,
and the computer's web browser will be directed to the address."""
try:
server = cls(('', port), RequestHandlerClass)
active = True
except socket.error:
active = False
else:
addr, port = server.socket.getsockname()
print('Serving HTTP on', addr, 'port', port, '...')
finally:
port = '' if port == 80 else ':' + str(port)
addr = 'http://localhost' + port + '/'
webbrowser.open(addr)
if active:
try:
server.serve_forever()
except KeyboardInterrupt:
print('Keyboard interrupt received: EXITING')
finally:
server.server_close()
def handle_error(self, request, client_address):
"""Process exceptions raised by the RequestHandlerClass.
Overriding this method is necessary for two different reasons:
(1) SystemExit exceptions are incorrectly caught otherwise and
(2) Socket errors should be silently passed in the server code"""
klass, value = sys.exc_info()[:2]
if klass is SystemExit:
self.__exit = value
self._BaseServer__serving = None
elif issubclass(klass, socket.error):
pass
else:
super().handle_error(request, client_address)
def serve_forever(self, poll_interval=0.5):
"""Handle all incoming client requests forever.
This method has been overridden so that SystemExit exceptions
raised in the RequestHandlerClass can be re-raised after being
caught in the handle_error method above. This allows servlet
code to terminate server execution if so desired or required."""
super().serve_forever(poll_interval)
if self._BaseServer__serving is None:
raise self.__exit
