How to kill a SocketServer?

[Paul Rubin]

Let's say you have a SocketServer with the threading mix-in and you
run serve_forever on it. How can you shut it down, or rather, how can
it even shut itself down? Even if you use a handle_request loop
instead of serve_forever, it still seems difficult:

class myserver(Thread ingMixIn, TCPServer): pass
server = myserver(...)
server.shutdown = False
while not server.shutdown :
server.handle_r equest()

Some code in the request handler eventually sets server.shutdown to
True (say on receiving a "shutdown" command from the client), but by
then the main thread is already blocked waiting for another
connection. I ended up having the quit operation actually open a
loopback connection after setting the shutdown flag, just to unblock
the socket listener. But that seems insane.

Is there a better way?

[Andrew Dalke]

Paul Rubin wrote:

Let's say you have a SocketServer with the threading mix-in and you
run serve_forever on it. How can you shut it down, or rather, how can
it even shut itself down?

I looked at CherryPy's server because I know it uses Python's
BaseHTTPServer which is derived from SocketServer, and I know
it's multithreaded.

Turns out I don't know enough about it to make a reasonable
summary, unless I do a lot more research. Here's some text
from _cphttpserver

class PooledThreadSer ver(SocketServe r.TCPServer):

allow_reuse_add ress = 1

"""A TCP Server using a pool of worker threads. This is superior to the
alternatives provided by the Python standard library, which only offer
(1) handling a single request at a time, (2) handling each request in
a separate thread (via ThreadingMixIn) , or (3) handling each request in
a separate process (via ForkingMixIn). It's also superior in some ways
to the pure async approach used by Twisted because it allows a more
straightforward and simple programming model in the face of blocking
requests (i.e. you don't have to bother with Deferreds)."""

which means it went a different route. Looks like a
request comes in and is put to a work queue. Clients get
from it. There's a special work queue item to tell
the threads to stop.

Andrew
da***@dalkescie ntific.com

[Skip Montanaro]

Paul> Let's say you have a SocketServer with the threading mix-in and
Paul> you run serve_forever on it. How can you shut it down, or rather,
Paul> how can it even shut itself down? Even if you use a
Paul> handle_request loop instead of serve_forever, it still seems
Paul> difficult:

Paul> class myserver(Thread ingMixIn, TCPServer): pass
Paul> server = myserver(...)
Paul> server.shutdown = False
Paul> while not server.shutdown :
Paul> server.handle_r equest()

Paul> Some code in the request handler eventually sets server.shutdown
Paul> to True (say on receiving a "shutdown" command from the client),
Paul> but by then the main thread is already blocked waiting for another
Paul> connection.

I use precisely that scheme with (I think *) no problem. The only maybe
significant difference I see is that I subclass ThreadingMixin so that it
creates daemon threads:

class DaemonThreadMix In(SocketServer .ThreadingMixIn ):
def process_request _thread(self, request, client_address) :
try:
self.finish_req uest(request, client_address)
self.close_requ est(request)
except:
self.handle_err or(request, client_address)
self.close_requ est(request)

def process_request (self, request, client_address) :
t = threading.Threa d(target = self.process_re quest_thread,
args = (request, client_address) )
t.setDaemon(1)
t.start()

class GenericServer(D aemonThreadMixI n, SocketServer.TC PServer):
...

Skip

(*) Maybe my XML-RPC server actually accepts one more connection after I set
server.shutdown to True before it actually exits. I'll have to take a look
at that.

[Paul Rubin]

Skip Montanaro <sk**@pobox.com > writes:

I use precisely that scheme with (I think *) no problem. The only maybe
significant difference I see is that I subclass ThreadingMixin so that it
creates daemon threads: ...
According to the docs, you don't need the subclass, you can just set the
"daemon_threads " property on the server, e.g.

class myserver(Thread ingMixIn, TCPServer): pass
server = myserver(...)
server.daemon_t hreads = True
server.serve_fo rever()

You have to set the flag before you actually start the server, as above.
(*) Maybe my XML-RPC server actually accepts one more connection after I set
server.shutdown to True before it actually exits. I'll have to take a look
at that.

Yes, this is precisely what I'm asking. How do you get the server to
go away without going out of your way to connect to it again? Don't you
notice if it stays around?

[Skip Montanaro]

I use precisely that scheme with (I think *) no problem. The only
maybe significant difference I see is that I subclass ThreadingMixin
so that it creates daemon threads: ...
Paul> According to the docs, you don't need the subclass, you can just
Paul> set the "daemon_threads " property on the server, e.g.
...

It's possible that my subclassing existed before this feature was available
(it's been in use for about 5 years now) or that I just missed that
mechanism.
(*) Maybe my XML-RPC server actually accepts one more connection
after I set server.shutdown to True before it actually exits. I'll
have to take a look at that.

Paul> Yes, this is precisely what I'm asking. How do you get the server
Paul> to go away without going out of your way to connect to it again?
Paul> Don't you notice if it stays around?

It fields lots of requests, so it's possible that another request arrives
after I exit, but I don't think that's the case. I'll try to take a look in
isolation when I have a moment.

Skip

[Paul Rubin]

Andrew Dalke <da***@dalkesci entific.com> writes:

which means it went a different route. Looks like a
request comes in and is put to a work queue. Clients get
from it. There's a special work queue item to tell
the threads to stop.

Well, ok, so the worker threads stop. How do you get the listener
thread to stop, since it's blocked waiting for a new connection to arrive?

[Skip Montanaro]

Paul> Yes, this is precisely what I'm asking. How do you get the server
Paul> to go away without going out of your way to connect to it again?
Paul> Don't you notice if it stays around?

Skip> It fields lots of requests, so it's possible that another request
Skip> arrives after I exit, but I don't think that's the case. I'll try
Skip> to take a look in isolation when I have a moment.

Here's what I do:

def serve_forever(s elf):
while self.serving:
r,w,e = select.select([self.socket], [], [], self.pause)
if r:
self.handle_req uest()

and set self.pause to something short-ish. The select call times out and
the server exits. Sorry I failed to remember that. It's been several years
since I modified this code.

Skip

[Andrew Dalke]

After I gave a reference to CherryPy's threaded SocketServer-based
http server code Paul Rubin followed up:

Well, ok, so the worker threads stop. How do you get the listener
thread to stop, since it's blocked waiting for a new connection to arrive?

I don't know the code well enough. You might want to look
through it yourself. I think it works by implementing a
new 'server_activat e()' to implement a timeout
class CherryHTTPServe r(BaseHTTPServe r.HTTPServer):
def server_activate (self):
"""Override server_activate to set timeout on our listener
socket"""
self.socket.set timeout(1)
BaseHTTPServer. HTTPServer.serv er_activate(sel f)
followed by a check for the timeeout

def handle_request( self):
"""Override handle_request to trap timeout exception."""
try:
BaseHTTPServer. HTTPServer.hand le_request(self )
except socket.timeout:
# The only reason for the timeout is so we can notice keyboard
# interrupts on Win32, which don't interrupt accept() by default
return 1
except KeyboardInterru pt:
_cpLogMessage(" <Ctrl-C> hit: shutting down", "HTTP")
self.shutdown()
with the redefined serve_forever() done as

def serve_forever(s elf):
"""Override serve_forever to handle shutdown."""
self.__running = 1
while self.__running:
self.handle_req uest()

The __running attribute is set in the shutdown() method

def shutdown(self):
self.__running = 0
It looks like some special attention is needed when the socket
is in timeout mode

def get_request(sel f):
# With Python 2.3 it seems that an accept socket in timeout (nonblocking
) mode
# results in request sockets that are also set in nonblocking mode. Sin
ce that doesn't play
# well with makefile() (where wfile and rfile are set in SocketServer.p
y) we explicitly set
# the request socket to blocking

request, client_address = self.socket.acc ept()
request.setbloc king(1)
return request, client_address
Hmmm, and I've just copied and pasted the entire implementation of

class CherryHTTPServe r(BaseHTTPServe r.HTTPServer):

given in my CherryPy-2.0.0/cherrypy/_cphttpserver.p y

Andrew
da***@dalkescie ntific.com

[Paul Rubin]

Skip Montanaro <sk**@pobox.com > writes:

def serve_forever(s elf):
while self.serving:
r,w,e = select.select([self.socket], [], [], self.pause)
if r:
self.handle_req uest()

and set self.pause to something short-ish. The select call times out and
the server exits.

Ah, good point. Something like this should probably be added to
SocketServer.py (optional timeout parameter to serve_forever), or at
least the trick should be mentioned in the docs.

Thanks.

[guido]

[Skip Montanaro]

def serve_forever(s elf):
while self.serving:
r,w,e = select.select([self.socket], [], [], self.pause) if r:
self.handle_req uest()

and set self.pause to something short-ish. The select call times out and the server exits.

[Paul Rubin] Ah, good point. Something like this should probably be added to
SocketServer.py (optional timeout parameter to serve_forever), or at
least the trick should be mentioned in the docs.

I like this idea, and perhaps you all could come up with some more
useful APIs in this area; I know that I often struggle a bit with
getting these servers to stop.

(I also like the idea of having the worker thread mixin part of the
standard library -- it seems generally useful.)

--Guido van Rossum (home page: http://www.python.org/~guido/)