How to implement Timeout in BaseHTTPServer.BaseHTTPRequestHandler Python

Assuming I've understood your question correctly, you can't implement a read timeout in do_GET since the request has already been read by the time this method is called.

Since BaseHTTPRequestHandler extends StreamRequestHandler which in turn extends BaseRequestHandler, you can override setup() to initialise the socket with a timeout:

class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
  def setup(self):
    BaseHTTPServer.BaseHTTPRequestHandler.setup(self)
    self.request.settimeout(60)

  def do_GET(self):
    # ...

I actually found that setting a value for self.timeout in def setup didn't work if I then called the superclass. It looks like the Handler's setup and init methods aren't called during creation of the HTTPServer instance. I used pydevd to confirm this.

So, I took a backward step:

httpd = BaseHTTPServer.HTTPServer(server_address, MyHttpHandler)
httpd.timeout = 10

Which works perfectly, and without overriding core code, or building your own derivative classes. It looks like you'd have to overwrite the HTTPServer code, rather than the Handler code, if you wanted to do it that way.

As pointed out by Tey' in TinBane's answer, timeout attribute will not work with serve_forever() method, as stated in the doc:

The workaround is to use a custom loop for handling the request as pointed out by user3483992

while True: server.handle_request()

handle_request() will then trigger the method handle_timeout() at the end of the given timeout as expected:

...except the handle_timeout method is doing nothing:

A solution is then to provide another implementation for this method, such as (credit here):

server.handle_timeout = lambda: (_ for _ in ()).throw(TimeoutError())

In short:

try:
     server = HTTPServer(('', PORT_NUMBER), `yourAwesomeRequestHandler`)
     server.timeout = 10
     server.handle_timeout = lambda: (_ for _ in ()).throw(TimeoutError())
     while True: server.handle_request()
except TimeoutError:
    // TODO

I managed to get timeouts working for HTTP requests with

self.rfile._sock.settimeout(60)

Hope this helps

class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
    timeout = 60 # StreamRequestHandler.setup
    def do_GET(self):
        # Doing Some Stuff.

timeout = 0.1  # seconds

class WebHTTPServer(BaseHTTPServer.HTTPServer):
    def server_bind(self):
        BaseHTTPServer.HTTPServer.server_bind(self)
        self.socket.settimeout(timeout)

class WebReqHandler(BaseHTTPServer.BaseHTTPRequestHandler):
    <etc> 

if __name__ == '__main__':
    server = WebHTTPServer(('',port), WebReqHandler)
    while 1:
        server.handle_request()
        <do other things>

class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def __init__(self, request, client_address, server):
    BaseHTTPServer.BaseHTTPRequestHandler.__init__(self, request, client_address, server)   
    self.timeout = 60

Given the popularity of python's http.server module, a minimal drop-in copy-pasteable replacement for python3 -m http.server with a timeout is likely useful for others that find this page:

~20 second timeout:

python3 -c "from http.server import HTTPServer, SimpleHTTPRequestHandler
import time
start = time.time()
httpd = HTTPServer(('', 8000), SimpleHTTPRequestHandler)
while not time.time() - start > 20:
    httpd.handle_request()"

The problem I ran into with the answers based on using handle_request() instead of serve_forever() is that the server won't time out until it receives the next request. I need a solution for when the server has stopped getting requests but is still hanging around for some reason, so that won't work for me.

Thanks to Gregoire Cattan's answer though, I realized that I can get the behavior I want by subclassing HTTPServer and overriding the service_actions() method. It's called within the serve_forever() loop, so putting the timeout logic there means it will be triggered even in the absence of incoming requests.

#!/usr/bin/env python

"""Run a HTTP server until it times out."""

from http.server import HTTPServer, SimpleHTTPRequestHandler
from sys import stderr
from time import time


PORT = 1313
TIMEOUT = 5


class Server(HTTPServer):
    """Expiring HTTP Server."""

    timeout = TIMEOUT

    def __init__(self, *args, **kwargs):
        """Initialize the server with a start time."""
        self.started = time()
        super().__init__(*args, **kwargs)

    @property
    def age(self):
        """Return the number of seconds the server has been alive."""
        return time() - self.started

    def service_actions(self, *args, **kwargs):
        """Time out if the server has expired."""
        print(self.age, file=stderr)
        if self.age > self.timeout:
            self.stopped = time()
            raise TimeoutError()
        super().service_actions(*args, **kwargs)


def run():
    """Run the web server."""
    server = Server(("", PORT), SimpleHTTPRequestHandler)
    print(f"Starting server at {server.started} with a {TIMEOUT} second timeout.\n", file=stderr)

    try:
        server.serve_forever()
    except TimeoutError:
        ...
    finally:
        print(f"\nShutting down server at {server.stopped}.", file=stderr)
        server.server_close()


if __name__ == "__main__":
    run()

Here's the output:

Starting server at 1715792021.774305 with a 5 second timeout.

0.5272078514099121
1.0283708572387695
1.5295538902282715
2.0307466983795166
2.5319831371307373
3.032681941986084
3.5338847637176514
4.0351338386535645
4.536334037780762
5.037556886672974

Shutting down server at 1715792026.811923.

This way, by overriding BaseRequestHandler setup(self) method, then calling setup(self) method overriden in StreamRequestHandler class.

from http.server import BaseHTTPRequestHandler
from socketserver import StreamRequestHandler

class MyHttpServerHandler(BaseHTTPRequestHandler):

    def setup(self):
         StreamRequestHandler.timeout = 10  # seconds
         StreamRequestHandler.setup(self)