SocketServer employs select.select to achieve timeout behaviour on accepting new requests.  Unfortunately, the way this is implemented makes it tricky to bypass this behaviour for users that want to achieve timeout in a different manner.
This defect presents two patches.  One shows how we delegate the timeout to a new function, _get_request_timeout(), that can be overridden by subclasses.
The second shows a concrete version of this function, one that uses the socket's own timeout property rather than select, to get the same behaviour.

As discussed on python-dev, I'm against this change. Furthermore, removing the explicit select() call also removes the opportunity to use a wake-up fd instead of the current polling mechanism.

What's wrong with making functionality overridable, Antoine?  By all means, let's keep the select() but allow subclasses to elect not to use it.

As for the wakeup fd, there isn't such a thing.  Why object on the basis of a hypothetical feature which might be added later?  And should it be added later, it would require changes to SocketServer anyway.  Why not arrange it so that such functionality can be added in an extensible manner?

> What's wrong with making functionality overridable, Antoine?  By all
> means, let's keep the select() but allow subclasses to elect not to use 
> it.

It's making the implementation more complex for no obvious point.
Using select() is not a bug in itself.
Furthermore, you can simply reimplement serve_forever() in your subclass, if you really want it.

Btw, I have found that socket.closesocket() is quite able, on Windows, to abort an ongoing accept() call.

FTR the python-dev discussion looks like it is <https://marc.info/?l=python-dev&m=133169928819705&w=2>. The argument for this change seems to be to support users monkey-patching the socket module, but not monkey-patching the select module. But this seems unreasonable to me.

I also agree the would make it harder to fix the wakeup polling problem. I suggest to reject this change.

Also, if you want a method to be overridable in subclasses, I don’t think it should have an underscore prefix.

Antoine Pitrou: "...  I'm against this change ..."

Martin Panter: "... But this seems unreasonable to me. ..."

I close the issue. You can use asyncio for non-blocking networking code. Or have a look at Twisted, Tornado, eventlet, etc.

If you really want to hack socketserver, I suggest you to copy the whole socketserver.py file. But asynchronous programming is a hard problem which requires more than modiying a single function. Slowly, you will built something similar the the project that I cited.

Nice necro :)
Socketserver is already subclassable and overridable for so many things.  Hard to understand the reluctancy to _allow_ for a different way to handle accept timeouts.  But this is also why I stopped contributing to core, because it turned out to be more about lobbying than anything else.  Anyway this is already implemented in PythonClassic, so no need for me to push it upstream :)

> Hard to understand the reluctancy to _allow_ for a different way to handle accept timeouts.  But this is also why I stopped contributing to core, because it turned out to be more about lobbying than anything else.

To get a change merged into Python, you need to find someone who wants to be responsible for it: not only merge the change, but also maintain the code later. I touched socketserver recently for my work on making the Python CI more reliable. It was not easy to get a review. I ended to merge the changes with no review (if I recall properly).

I dislike socketserver design: it tries to be too generic. Like supporting TCP and UDP, support threading and forking models, etc.

To be honest, I didn't look at your issue. I only close it for bug triage, since there was no activity since 2016 and 2 core devs were against the change.

And you want to revisit the change, please reopen the issue.