The http.server module in Python is a simple yet powerful tool for creating HTTP servers. It is included in the standard library and allows developers to easily set up a web server without the need for third-party frameworks or applications. The module provides classes that make it straightforward to handle HTTP requests and craft HTTP responses.
One of the primary classes in the http.server module is HTTPServer, which is a base class for creating servers. It uses the SocketServer module to handle underlying network communications. On top of HTTPServer, the module provides two other classes, BaseHTTPRequestHandler and SimpleHTTPRequestHandler, to handle requests from clients and serve files from the local directory, respectively.
BaseHTTPRequestHandler is an abstract class that defines methods such as do_GET() and do_POST(), which can be overridden to handle specific HTTP methods. SimpleHTTPRequestHandler, on the other hand, extends BaseHTTPRequestHandler and serves files from the current directory or a specified path, making it useful for serving static content quickly.
The http.server module also provides the CGIHTTPRequestHandler class for handling CGI scripts, although it is less commonly used today due to the shift towards more contemporary application frameworks.
Using the http.server module is a great way to understand the basics of how HTTP servers work and can be a stepping stone to using more advanced web frameworks. Here is a simple example of how to use the http.server module to set up a basic server:
import http.server
import socketserver
PORT = 8000
Handler = http.server.SimpleHTTPRequestHandler
with socketserver.TCPServer(("", PORT), Handler) as httpd:
print("Server running at port", PORT)
httpd.serve_forever()
This code snippet creates a simple HTTP server that listens on port 8000 and serves files from the current directory. The server runs indefinitely until manually stopped, responding to incoming HTTP requests with the content of the files it serves.
Setting up a basic HTTP server
To set up a basic HTTP server using the http.server module, you will need to import the necessary classes and specify a port number on which the server should listen for incoming requests. The default port for HTTP servers is 80, but for development purposes, you can use any available port like 8000 as shown in the example above.
The Handler variable is assigned to the SimpleHTTPRequestHandler class, which will handle the HTTP requests to serve files. The TCPServer class is used to create a TCP server that listens on the specified port. The TCPServer class takes a tuple of the host address and port number, along with the handler class, as its arguments.
The with statement is used to ensure that the server is properly cleaned up after it’s no longer in use. The serve_forever() method of the httpd object is then called to start the server and keep it running.
If you want to serve files from a different directory, you can subclass SimpleHTTPRequestHandler and override the translate_path() method. Here’s an example:
import os
import http.server
import socketserver
PORT = 8000
class CustomHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
def translate_path(self, path):
# Serve files from the 'public' directory
public_dir = os.path.join(os.path.dirname(__file__), 'public')
return os.path.join(public_dir, path.strip('/'))
Handler = CustomHTTPRequestHandler
with socketserver.TCPServer(("", PORT), Handler) as httpd:
print("Server running at port", PORT)
httpd.serve_forever()
In this example, we create a new class CustomHTTPRequestHandler that extends SimpleHTTPRequestHandler. We override the translate_path() method to serve files from a ‘public’ directory instead of the current directory. That’s useful when you want to keep your server code separate from the files you are serving.
Setting up a basic HTTP server with the http.server module is straightforward and requires only a few lines of code. However, this setup is only recommended for development and testing purposes. For production use, it’s advisable to use a more robust and secure web server.
Handling GET and POST requests
Handling GET and POST requests is an essential part of creating a functional HTTP server. The BaseHTTPRequestHandler class provides a starting point for handling these requests. By overriding the do_GET() and do_POST() methods, you can customize how your server responds to different types of HTTP requests.
Below is an example of how you might handle a GET request to serve a simple HTML page:
import http.server
import socketserver
PORT = 8000
class MyHTTPRequestHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(b'<html><body><h1>Hello, World!</h1></body></html>')
Handler = MyHTTPRequestHandler
with socketserver.TCPServer(("", PORT), Handler) as httpd:
print("Server running at port", PORT)
httpd.serve_forever()
In this code, we define a new class MyHTTPRequestHandler that inherits from BaseHTTPRequestHandler. We then override the do_GET() method to send a 200 OK response, along with an HTML page as the content. This is a very basic example, but you can expand on this to serve dynamic content or even create a REST API.
For handling POST requests, you would override the do_POST() method. Here’s an example that handles form data sent through a POST request:
import http.server
import socketserver
from urllib.parse import parse_qs
PORT = 8000
class MyHTTPRequestHandler(http.server.BaseHTTPRequestHandler):
def do_POST(self):
content_length = int(self.headers['Content-Length'])
post_data = self.rfile.read(content_length)
post_data = parse_qs(post_data.decode('utf-8'))
# Process the data and respond
self.send_response(200)
self.send_header('Content-type', 'text/plain')
self.end_headers()
response = f"Received: {post_data}"
self.wfile.write(response.encode('utf-8'))
Handler = MyHTTPRequestHandler
with socketserver.TCPServer(("", PORT), Handler) as httpd:
print("Server running at port", PORT)
httpd.serve_forever()
In this example, the do_POST() method reads the content length from the headers, then reads the POST data from the request. It uses parse_qs from the urllib.parse module to parse the POST data into a dictionary. After processing the data, it sends a plain text response back to the client.
These examples demonstrate how you can handle GET and POST requests using the http.server module. With these basics, you can build upon them to create more complex server logic tailored to your application’s needs. Remember to always validate and sanitize user input when handling POST requests to protect your server from malicious data.
It is important to note that while the http.server module is suitable for learning and development, it is not designed for production use. In a production environment, it’s recommended to use a more secure and scalable server such as Gunicorn or uWSGI behind a proper web server like Nginx or Apache.
Customizing server behavior
Customizing server behavior goes beyond handling HTTP requests. You can also define how your server responds to different situations, manage server-side state, and even integrate with other Python libraries and frameworks. Let’s dive into some of the ways we can customize the behavior of our server.
Overriding BaseHTTPRequestHandler Methods
One of the simplest ways to customize server behavior is by overriding the methods in BaseHTTPRequestHandler. For instance, you can override the log_message() method to customize the way server requests are logged:
class MyHTTPRequestHandler(http.server.BaseHTTPRequestHandler):
def log_message(self, format, *args):
# Write the log message to a file
with open("server.log", "a") as log_file:
log_file.write("%s - - [%s] %sn" %
(self.address_string(),
self.log_date_time_string(),
format%args))
This custom log_message() method writes log entries to a file named server.log instead of printing them to the console. This can be useful for maintaining server logs over time or for analyzing traffic patterns.
Integrating with Other Libraries
You can also integrate your HTTP server with other Python libraries to extend its capabilities. For instance, if you want to add database functionality to your server, you can use a library like SQLAlchemy:
from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData
# Database setup
engine = create_engine('sqlite:///mydatabase.db')
metadata = MetaData()
users_table = Table('users', metadata,
Column('id', Integer, primary_key=True),
Column('name', String),
Column('email', String))
metadata.create_all(engine)
class MyHTTPRequestHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
# Query the database and return results
with engine.connect() as connection:
result = connection.execute(users_table.select())
users = [dict(row) for row in result]
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
self.wfile.write(json.dumps(users).encode('utf-8'))
In this example, we set up a SQLite database with a table for users. We then use SQLAlchemy to query the database in the do_GET() method and return the results as a JSON response.
Managing Server-Side State
You may also want to manage server-side state, such as user sessions or application settings. One way to do that is by using global variables or a class to store state information:
class MyServerState:
def __init__(self):
self.sessions = {}
self.settings = {'maintenance_mode': False}
server_state = MyServerState()
class MyHTTPRequestHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
if server_state.settings['maintenance_mode']:
self.send_response(503)
self.send_header('Content-type', 'text/plain')
self.end_headers()
self.wfile.write(b'Server is currently in maintenance mode.')
else:
# Normal request handling
pass
In this example, we create a MyServerState class to store sessions and settings. The do_GET() method checks if the server is in maintenance mode and responds with a 503 Service Unavailable status if so. Otherwise, it proceeds with normal request handling.
By customizing the behavior of your HTTP server, you can create a tailored solution that fits the specific needs of your application. Whether it is changing the way requests are logged, adding database support, or managing server-side state, there’s a lot you can do with Python’s http.server module. However, keep in mind that for more advanced features and better performance, you might want to look into using a full-fledged web framework like Flask or Django.
