Scribd
Upload
2 views

Assignment_HTTP_Library

The assignment involves creating a basic HTTP server in Python that handles HTTP GET requests and serves static HTML content. Key requirements include implementing a SimpleHTTPServer class, managing client connections with multi-threading, and providing error handling for unsupported HTTP methods. Additionally, students are tasked with submitting the complete script and a README file for server operation and testing.

Uploaded by

Jatin raksaniya
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
2 views

Assignment_HTTP_Library

The assignment involves creating a basic HTTP server in Python that handles HTTP GET requests and serves static HTML content. Key requirements include implementing a SimpleHTTPServer class, managing client connections with multi-threading, and providing error handling for unsupported HTTP methods. Additionally, students are tasked with submitting the complete script and a README file for server operation and testing.

Uploaded by

Jatin raksaniya
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Assignment: Create a Basic HTTP Protocol Library

Objective
The objective of this assignment is to understand the basics of HTTP and socket programming by
creating a simple HTTP server in Python. The server will handle HTTP GET requests and serve static
HTML content.

Requirements
1. Create a Python class SimpleHTTPServer.

2. The server should listen on a specified host and port.

3. The server should handle basic HTTP GET requests.

4. The server should respond with static HTML content.

5. Implement error handling for unsupported HTTP methods.

6. Use multi-threading to handle multiple client connections simultaneously.

Instructions
1. Setting Up the Server:

1. Create a class named SimpleHTTPServer.

2. Initialize a socket to listen for incoming connections on a specified host and


port.

2. Handling Client Connections:

1. Accept incoming connections.

2. Read and parse HTTP requests from the client.

3. Handle HTTP GET requests.

4. Generate and send HTTP responses to the client.

5. Close the client connection.

3. Serving Static Content:

1. Respond with a simple HTML page for GET requests.

4. Error Handling:

1. Respond with a 405 Method Not Allowed status for unsupported HTTP
methods.

5. Multi-threading:

1. Use threading to handle multiple client connections simultaneously.

Example Code Structure


Below is a skeleton code structure to help you get started:

Python
import socket
import threading
import os
import logging

class SimpleHTTPServer:
def __init__(self, host='127.0.0.1', port=8080):
self.host = host
self.port = port
# TODO: Initialize server socket
# TODO: Bind socket to host and port
# TODO: Start listening for connections

# Set up logging
logging.basicConfig(filename='server.log', level=logging.INFO,
format='%(asctime)s - %(message)s')

def start(self):
# TODO: Accept incoming connections and handle each client in a
new thread
pass

def handle_client(self, client_socket):


# TODO: Read the HTTP request from the client socket
# TODO: Log the request
# TODO: Handle the request and generate a response
# TODO: Send the response back to the client
# TODO: Close the client socket
pass

def handle_request(self, request):


# TODO: Parse the HTTP request to extract method and path
# TODO: Handle GET requests and generate responses
# TODO: Handle unsupported methods
pass

def get_response(self, path):


# TODO: Serve static files from the 'static' directory
# TODO: Handle file not found (404 Not Found)
response_body = f"<html><body><h1>Hello, you requested
{path}</h1></body></html>"
response = (
"HTTP/1.1 200 OK\r\n"
"Content-Type: text/html\r\n"
"Content-Length: " + str(len(response_body)) + "\r\n"
"Connection: close\r\n"
"\r\n"
+ response_body
)
return response.encode('utf-8')
def method_not_allowed_response(self):
# TODO: Generate a 405 Method Not Allowed response
response_body = "<html><body><h1>405 Method Not
Allowed</h1></body></html>"
response = (
"HTTP/1.1 405 Method Not Allowed\r\n"
"Content-Type: text/html\r\n"
"Content-Length: " + str(len(response_body)) + "\r\n"
"Connection: close\r\n"
"\r\n"
+ response_body
)
return response.encode('utf-8')

if __name__ == "__main__":
server = SimpleHTTPServer()
server.start()

Tasks
1. Initialize the Server:

1. Complete the __init__ method to initialize the server socket.

2. Bind the socket to the specified host and port.

3. Start listening for incoming connections.

2. Handle Client Connections:

1. Implement the start method to accept incoming connections.

2. Create a new thread for each client connection.

3. Parse HTTP Requests:

1. Implement the handle_client method to read the request from the client
socket.

2. Parse the HTTP request to extract the method and path.

4. Generate HTTP Responses:

1. Implement the handle_request method to handle GET requests and generate


appropriate responses.

2. Implement the get_response method to return a simple HTML response for


GET requests.

3. Implement the method_not_allowed_response method to return a 405


Method Not Allowed response for unsupported methods.

5. Multi-threading:
1. Ensure that the server can handle multiple clients simultaneously using
threading.

Submission
Submit the following:

1. The complete Python script for the SimpleHTTPServer class.

2. A README file explaining how to run the server and test it using a web browser or an
HTTP client tool like curl or Postman.

Bonus
1. Serve Static Files:

1. Extend the server to serve static files (e.g., HTML, CSS, JS) from a directory.

2. Logging:

1. Implement logging to record incoming requests and server responses.

Evaluation Criteria
• Correct implementation of the server initialization and socket setup.

• Proper handling of client connections and HTTP requests.

• Correct generation of HTTP responses.

• Implementation of multi-threading for handling multiple clients.

• Code readability and comments explaining the functionality.


Good luck, and have fun building your basic HTTP protocol library!

This assignment should help students understand the fundamentals of HTTP and socket
programming while giving them hands-on experience in creating a simple HTTP server.

You might also like