def run(self):
self.running = True
try:
log.debug("worker %s waiting for work", self.getName())
while self.running: # loop over all connections in the queue
self.csock, self.caddr = self.server.workqueue.get()
if self.csock is None and self.caddr is None:
# this was a 'stop' sentinel
self.running = False
break
log.debug("worker %s got a client connection %s",
self.getName(), self.caddr)
self.csock = SocketConnection(self.csock)
if self.handleConnection(self.csock):
while self.running: # loop over all requests during a single connection
try:
self.callback.handleRequest(self.csock)
except (socket.error, ConnectionClosedError):
# client went away.
log.debug("worker %s client disconnected %s",
self.getName(), self.caddr)
break
self.csock.close()
finally:
try:
self.server.threadpool.remove(self)
except KeyError:
pass
log.debug("worker %s stopping", self.getName())
class SocketWorker(threadutil.Thread):
"""worker thread to process requests"""
def __init__(self, server, callback):
super(SocketWorker, self).__init__()
self.setDaemon(True)
self.server = server
self.callback = callback
if os.name == "java":
# jython names every thread 'Thread', so we improve that a little
self.setName("Thread-%d" % id(self))
def run(self):
self.running = True
try:
log.debug("new worker %s", self.getName())
while self.running: # loop over all connections in the queue
self.csock, self.caddr = self.server.workqueue.get()
if self.csock is None and self.caddr is None:
# this was a 'stop' sentinel
self.running = False
break
log.debug("worker %s got a client connection %s",
self.getName(), self.caddr)
self.csock = SocketConnection(self.csock)
if self.handleConnection(self.csock):
self.server.threadpool.updateWorking(
1) # tell the pool we're working
try:
while self.running: # loop over all requests during a single connection
try:
self.callback.handleRequest(self.csock)
except (socket.error, ConnectionClosedError):
# client went away.
log.debug("worker %s client disconnected %s",
self.getName(), self.caddr)
break
self.csock.close()
finally:
# make sure we tell the pool that we are no longer working
self.server.threadpool.updateWorking(-1)
# Note: we don't swallow exceptions here anymore because @Pyro.callback doesn't
# do anything anymore if we do (the re-raised exception would be swallowed...)
#except Exception:
# exc_type, exc_value, _ = sys.exc_info()
# log.warn("swallow exception in worker %s: %s %s",self.getName(),exc_type,exc_value)
finally:
self.server.threadpool.remove(self)
log.debug("stopping worker %s", self.getName())
def handleConnection(self, conn):
try:
if self.callback.handshake(conn):
return True
except (socket.error, PyroError):
x = sys.exc_info()[1]
log.warn("error during connect: %s", x)
conn.close()
return False
def run(self):
self.running=True
try:
log.debug("worker %s waiting for work", self.getName())
while self.running: # loop over all connections in the queue
self.csock,self.caddr = self.server.workqueue.get()
if self.csock is None and self.caddr is None:
# this was a 'stop' sentinel
self.running=False
break
log.debug("worker %s got a client connection %s", self.getName(), self.caddr)
self.csock=SocketConnection(self.csock)
if self.handleConnection(self.csock):
while self.running: # loop over all requests during a single connection
try:
self.callback.handleRequest(self.csock)
except (socket.error,ConnectionClosedError):
# client went away.
log.debug("worker %s client disconnected %s", self.getName(), self.caddr)
break
self.csock.close()
finally:
try:
self.server.threadpool.remove(self)
except KeyError:
pass
log.debug("worker %s stopping", self.getName())
def handleConnection(self, sock):
try:
csock, caddr=sock.accept()
log.debug("connection from %s",caddr)
if Pyro.config.COMMTIMEOUT:
csock.settimeout(Pyro.config.COMMTIMEOUT)
except socket.error:
x=sys.exc_info()[1]
err=getattr(x,"errno",x.args[0])
if err in ERRNO_RETRIES:
# just ignore this error for now and continue
log.warn("accept() failed errno=%d, shouldn't happen", err)
return None
if err in ERRNO_BADF:
# our server socket got destroyed
raise ConnectionClosedError("server socket closed")
raise
try:
conn=SocketConnection(csock)
if self.callback.handshake(conn):
return conn
except (socket.error, PyroError):
x=sys.exc_info()[1]
log.warn("error during connect: %s",x)
csock.close()
return None
class SocketWorker(threadutil.Thread):
"""worker thread to process requests"""
def __init__(self, server, callback):
super(SocketWorker, self).__init__()
self.setDaemon(True)
self.server = server
self.callback = callback
def run(self):
self.running = True
try:
log.debug("worker %s waiting for work", self.getName())
while self.running: # loop over all connections in the queue
self.csock, self.caddr = self.server.workqueue.get()
if self.csock is None and self.caddr is None:
# this was a 'stop' sentinel
self.running = False
break
log.debug("worker %s got a client connection %s",
self.getName(), self.caddr)
self.csock = SocketConnection(self.csock)
if self.handleConnection(self.csock):
while self.running: # loop over all requests during a single connection
try:
self.callback.handleRequest(self.csock)
except (socket.error, ConnectionClosedError):
# client went away.
log.debug("worker %s client disconnected %s",
self.getName(), self.caddr)
break
self.csock.close()
finally:
try:
self.server.threadpool.remove(self)
except KeyError:
pass
log.debug("worker %s stopping", self.getName())
def handleConnection(self, conn):
try:
if self.callback.handshake(conn):
return True
except (socket.error, PyroError), x:
log.warn("error during connect: %s", x)
conn.close()
return False
class SocketWorker(threadutil.Thread):
"""worker thread to process requests"""
def __init__(self, server, callback):
super(SocketWorker,self).__init__()
self.setDaemon(True)
self.server=server
self.callback=callback
def run(self):
self.running=True
try:
log.debug("worker %s waiting for work", self.getName())
while self.running: # loop over all connections in the queue
self.csock,self.caddr = self.server.workqueue.get()
if self.csock is None and self.caddr is None:
# this was a 'stop' sentinel
self.running=False
break
log.debug("worker %s got a client connection %s", self.getName(), self.caddr)
self.csock=SocketConnection(self.csock)
if self.handleConnection(self.csock):
while self.running: # loop over all requests during a single connection
try:
self.callback.handleRequest(self.csock)
except (socket.error,ConnectionClosedError):
# client went away.
log.debug("worker %s client disconnected %s", self.getName(), self.caddr)
break
self.csock.close()
finally:
try:
self.server.threadpool.remove(self)
except KeyError:
pass
log.debug("worker %s stopping", self.getName())
def handleConnection(self,conn):
try:
if self.callback.handshake(conn):
return True
except (socket.error, PyroError), x:
log.warn("error during connect: %s",x)
conn.close()
return False
def run(self):
self.running = True
try:
log.debug("new worker %s", self.getName())
while self.running: # loop over all connections in the queue
self.csock, self.caddr = self.server.workqueue.get()
if self.csock is None and self.caddr is None:
# this was a 'stop' sentinel
self.running = False
break
log.debug("worker %s got a client connection %s",
self.getName(), self.caddr)
self.csock = SocketConnection(self.csock)
if self.handleConnection(self.csock):
self.server.threadpool.updateWorking(
1) # tell the pool we're working
try:
while self.running: # loop over all requests during a single connection
try:
self.callback.handleRequest(self.csock)
except (socket.error, ConnectionClosedError):
# client went away.
log.debug("worker %s client disconnected %s",
self.getName(), self.caddr)
break
self.csock.close()
finally:
# make sure we tell the pool that we are no longer working
self.server.threadpool.updateWorking(-1)
# Note: we don't swallow exceptions here anymore because @Pyro.callback doesn't
# do anything anymore if we do (the re-raised exception would be swallowed...)
#except Exception:
# exc_type, exc_value, _ = sys.exc_info()
# log.warn("swallow exception in worker %s: %s %s",self.getName(),exc_type,exc_value)
finally:
self.server.threadpool.remove(self)
log.debug("stopping worker %s", self.getName())
class SocketServer(object):
"""transport server for socket connections, select/poll loop multiplex version."""
def __init__(self, callbackObject, host, port, timeout=None):
if os.name=="java":
raise NotImplementedError("select-based server is not supported for Jython, use the threadpool server instead")
log.info("starting select/poll socketserver")
self.sock=None
self.sock=createSocket(bind=(host,port), timeout=timeout)
self.clients=[]
self.callback=callbackObject
sockaddr=self.sock.getsockname()
if sockaddr[0].startswith("127."):
if host is None or host.lower()!="localhost" and not host.startswith("127."):
log.warn("weird DNS setup: %s resolves to localhost (127.x.x.x)",host)
host=host or sockaddr[0]
port=port or sockaddr[1]
self.locationStr="%s:%d" % (host,port)
def __del__(self):
if self.sock is not None:
self.sock.close()
self.sock=None
if hasattr(select,"poll"):
def requestLoop(self, loopCondition=lambda:True):
log.debug("enter poll-based requestloop")
try:
poll=select.poll() #@UndefinedVariable (pydev)
fileno2connection={} # map fd to original connection object
poll.register(self.sock.fileno(), select.POLLIN | select.POLLPRI) #@UndefinedVariable (pydev)
fileno2connection[self.sock.fileno()]=self.sock
while loopCondition():
polls=poll.poll(1000*Pyro.config.POLLTIMEOUT)
for (fd,mask) in polls: #@UnusedVariable (pydev)
conn=fileno2connection[fd]
if conn is self.sock:
try:
conn=self.handleConnection(self.sock)
except ConnectionClosedError:
log.info("server socket was closed, stopping requestloop")
return
if conn:
poll.register(conn.fileno(), select.POLLIN | select.POLLPRI) #@UndefinedVariable (pydev)
fileno2connection[conn.fileno()]=conn
else:
try:
self.callback.handleRequest(conn)
except (socket.error,ConnectionClosedError):
# client went away.
try:
fn=conn.fileno()
except socket.error:
pass
else:
poll.unregister(fn)
del fileno2connection[fn]
conn.close()
except KeyboardInterrupt:
log.debug("stopping on break signal")
pass
finally:
if hasattr(poll, "close"):
poll.close()
log.debug("exit poll-based requestloop")
else:
def requestLoop(self, loopCondition=lambda:True):
log.debug("entering select-based requestloop")
while loopCondition():
try:
rlist=self.clients[:]
rlist.append(self.sock)
try:
rlist,_,_=select.select(rlist, [], [], Pyro.config.POLLTIMEOUT)
except select.error:
if loopCondition():
raise
else:
# swallow the select error if the loopcondition is no longer true, and exit loop
# this can occur if we are shutting down and the socket is no longer valid
break
if self.sock in rlist:
rlist.remove(self.sock)
try:
conn=self.handleConnection(self.sock)
if conn:
self.clients.append(conn)
except ConnectionClosedError:
log.info("server socket was closed, stopping requestloop")
return
for conn in rlist[:]:
if conn in self.clients:
rlist.remove(conn)
try:
if self.callback:
self.callback.handleRequest(conn)
except (socket.error,ConnectionClosedError):
# client went away.
conn.close()
if conn in self.clients:
self.clients.remove(conn)
except socket.timeout:
pass # just continue the loop on a timeout
except KeyboardInterrupt:
log.debug("stopping on break signal")
break
log.debug("exit select-based requestloop")
def handleRequests(self):
raise NotImplementedError("select server doesn't currently support external request loop")
def handleConnection(self, sock):
try:
csock, caddr=sock.accept()
log.debug("connection from %s",caddr)
if Pyro.config.COMMTIMEOUT:
csock.settimeout(Pyro.config.COMMTIMEOUT)
except socket.error,x:
err=getattr(x,"errno",x.args[0])
if err in ERRNO_RETRIES:
# just ignore this error for now and continue
log.warn("accept() failed errno=%d, shouldn't happen", err)
return None
if err in ERRNO_BADF:
# our server socket got destroyed
raise ConnectionClosedError("server socket closed")
raise
try:
conn=SocketConnection(csock)
if self.callback.handshake(conn):
return conn
except (socket.error, PyroError), x:
log.warn("error during connect: %s",x)
csock.close()
