Timeouts not working?

[f11r]

• I'm submitting a ...
  [ x ] bug report
  [ ] feature request
  [ ] question about the decisions made in the repository

• What is the current behavior?

I'm running the following code:

import time

from cheroot.wsgi import PathInfoDispatcher
from cheroot.wsgi import Server
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    time.sleep(10)
    return 'Hello, World!'

server = Server(('0.0.0.0', 5000), PathInfoDispatcher({'/': app}), numthreads=1,
                timeout=1, shutdown_timeout=1)
server.safe_start()

1. When I curl localhost:5000 it responds after 10 seconds.
2. When I set timeout=11, then curl localhost:5000 and send an interrupt signal (Ctrl-C) to the webserver, it prints Keyboard Interrupt: shutting down, responds after 10 seconds and then exits.

• What is the expected behavior?

1. (When timeout=1) I would expect the request to timeout after 1 second and before a response can be sent.
2. (When timeout=11 and interrupt signal sent) I would expect the server to shut down after 1 second and before the response can be sent.

• Please tell us about your environment:

• Python version: Python 3.6.1 :: Continuum Analytics, Inc.
• Cheroot version: 5.8.2
• OS: Linux

Did I misunderstand what timeout and shutdown_timeout do?

[webknjaz]

timeout is applied to directly to the socket object: https://github.com/cherrypy/cheroot/blob/master/cheroot/server.py#L1553
so it's pretty low-level

shutdown_timeout allows server to complete processing existing connections: https://github.com/cherrypy/cheroot/blob/master/cheroot/workers/threadpool.py#L212

accepted_queue_timeout is timeout for request to be put into Queue: https://github.com/cherrypy/cheroot/blob/master/cheroot/workers/threadpool.py#L166

[f11r]

I'm not sure I can fully follow your answer. Is the described behavior above under "What is the current behavior?" the expected behavior?

[webknjaz]

You wrote, that you might've misunderstood the purpose of these arguments, thus I've checked the code and described the actual behavior.

It is not a bug. But if you want additional high-level timeout for requests it would require some additional coding.

[f11r]

Do you have an example when either timeout might be triggered?

[webknjaz]

timeout is a socket-level timeout, for all the cases, please consult with socket documentation.
shutdown_timeout is time Cheroot waits to forcibly shut down the socket if its still alive after sending _SHUTDOWNREQUEST to corresponding threads.
accepted_queue_timeout is time during which the incoming request must be put into request queue (which would happen if the queue is not full).

Regarding your wish to terminate request processing after timeout, I'd say its nearly impossible:

1. Requests are being processed within threads, and threads are unkillable (there are some hacks, but you'll likely end up with a dead lock if you try those)
2. CherryPy has this concept of the TimeoutMonitor, which is basically a separate thread. It just sets a boolean value to the requests and then internal machinery checks whether it's timed out or not. But this is only possible outside of request handler. When the user code comes into play, the framework has no control over it. Timeout may be triggered only once the handler execution complete. If user wants to terminate handler execution, they must do manual check for the request timeout flag from within handler and raise TimeoutError if so.

You could reimplement such behavior within your app or use CherryPy.

[f11r]

Thanks.

[webknjaz]

@f11r Here's an idea of the decorator, which could help you with timeout checks, you'll just need to turn your handler into generator and split it into slices inserting yields between potentially slow parts and then yield the final return value.

In [18]: timeout_happened = False

In [29]: def h_decor(h):
    ...:     from functools import wraps
    ...:     @wraps(h)
    ...:     def wrapper(inp):
    ...:         h_iter = h(inp)
    ...:         try:
    ...:             while True:
    ...:                 if timeout_happened:
    ...:                     h_iter.throw(TimeoutError)
    ...:                 else:
    ...:                     res = next(h_iter)
    ...:         except StopIteration:
    ...:             return res
    ...:     return wrapper
    ...: 

In [42]: def hndlr(inp):
    ...:     try:
    ...:         # do hard work
    ...:         print('before timeout')
    ...:         global timeout_happened
    ...:         timeout_happened = True
    ...:         yield
    ...:         print('timeout happened')
    ...:     except TimeoutError:
    ...:         print('timeout error got from decorator')
    ...:         

In [43]: d_hndlr = h_decor(hndlr)

In [44]: d_hndlr('asfdsaf')
before timeout
timeout error got from decorator