def addServer (self, client):
# this server answers to that client
peer= None
server= None
# this ReqSock will be thrown away.
socket= RequestSocket (client)
socket.write (['hit here'])
args= socket.read ()
self.debug (1, "args are: %s" % str(args))
what= next (args)
if what:
if what=='i am':
try:
url= args[0]
self.debug (1, "%s" % url.__class__)
if not isinstance (url, URL):
url= URL (url)
proto= url.proto ()
if proto=='umbie':
key= int (args[1])
peer= self.getNavel (str(url), key)
elif proto=='vice':
peer= self.getVice (str(url))
elif proto=='virtue':
peer= self.getVirtue (str(url))
else:
# bark!
pass
except NoParse:
socket.write (['bye'])
socket.close ()
else:
socket.write (['bye'])
socket.close ()
if peer:
socket.write (['ok'])
# create a Server of the correct class
# as defined in serverType
# TODO: I could pass the ReqSock() instead of the socket()
server= self._master._serverType (self._master, client)
# this server is the one answering to that client
peer.setServer (server)
server.start ()
else:
self.debug (1, 'no peer!')
self.debug (1, 'server %s added' % peer)
class Server(Thread, Object):
"""
serves only one client, another Navel out there or a Virtue or a Vice.
"""
def __init__(self, master, client):
Thread.__init__(self)
Object.__init__(self)
self._dead = False
self._master = master
# wrap the client (which is a socket())
# in a RequestSocket.
self._socket = RequestSocket(client)
self._clientName = self._socket.getSockName()
self.finished = False
self.setName(str(self))
def __str__(self):
try:
s = "[%d] %s:%s" % ((self.fileno(), ) + self._clientName)
except:
s = "%s:%s (closed)" % self._clientName
return s
def url(self):
return self._master.url()
def key(self):
return self._master.key()
def fileno(self):
return self._socket.fileno()
def read(self):
return self._socket.readPoll()
def readData(self, size):
return self._socket.readData(size)
def write(self, what):
self._socket.write(what)
def writeData(self, data):
self._socket.writeData(data)
def close(self):
self.debug(1, 'server: close!', fast=False, level=2)
self._socket.close()
self.finished = True
def run(self):
"""
main loop that should take care of from-the-bottom termination.
returns: once the client has quited.
"""
try:
args = self.read()
# main loop quited or EOF
self.finished = self._master._terminate or args == []
while not self.finished:
if args:
# it might not read anything
try:
what = next(args)
self.finished = self.attend(what, args)
except:
(e, v, tb) = sys.exc_info()
self.debug(5, 'exception caugh in server: %s' % e)
print_exception(e, v, tb)
self.debug(5, '---')
self.write(['error'])
self.finished = False
if not self.finished:
args = self.read()
# recalculate finished condition
# main loop quited or EOF
self.finished = self._master._terminate or args == []
except:
self.debug(5, 'exception caugh out server: %s' % e)
(e, v, tb) = sys.exc_info()
print_exception(e, v, tb)
# he quited, or terminated by main loop, remove ourselves from the system
self._dead = True
self.close()
self.debug(1, "dying")
self._master.delServer(self)
def attend(self, what, args):
"""
note: please reimplement in subclasses!
should recognize the request and answer it.
returns: True if (the client has quit/the socket is broken)
"""
return True
class Server (Thread, Object):
"""
serves only one client, another Navel out there or a Virtue or a Vice.
"""
def __init__ (self, master, client):
Thread.__init__ (self)
Object.__init__ (self)
self._dead= False
self._master= master
# wrap the client (which is a socket())
# in a RequestSocket.
self._socket= RequestSocket (client)
self._clientName= self._socket.getSockName ()
self.finished= False
self.setName (str (self))
def __str__ (self):
try:
s= "[%d] %s:%s" % ((self.fileno (),)+self._clientName)
except:
s= "%s:%s (closed)" % self._clientName
return s
def url (self):
return self._master.url ()
def key (self):
return self._master.key ()
def fileno (self):
return self._socket.fileno ()
def read (self):
return self._socket.readPoll ()
def readData (self, size):
return self._socket.readData (size)
def write (self, what):
self._socket.write (what)
def writeData (self, data):
self._socket.writeData (data)
def close (self):
self.debug (1, 'server: close!', fast=False, level=2)
self._socket.close ()
self.finished= True
def run (self):
"""
main loop that should take care of from-the-bottom termination.
returns: once the client has quited.
"""
try:
args= self.read ()
# main loop quited or EOF
self.finished= self._master._terminate or args==[]
while not self.finished:
if args:
# it might not read anything
try:
what= next (args)
self.finished= self.attend (what, args)
except:
(e, v, tb)= sys.exc_info ()
self.debug (5, 'exception caugh in server: %s' % e)
print_exception (e, v, tb)
self.debug (5, '---')
self.write (['error'])
self.finished= False
if not self.finished:
args= self.read ()
# recalculate finished condition
# main loop quited or EOF
self.finished= self._master._terminate or args==[]
except:
self.debug (5, 'exception caugh out server: %s' % e)
(e, v, tb)= sys.exc_info ()
print_exception (e, v, tb)
# he quited, or terminated by main loop, remove ourselves from the system
self._dead= True
self.close ()
self.debug (1, "dying")
self._master.delServer (self)
def attend (self, what, args):
"""
note: please reimplement in subclasses!
should recognize the request and answer it.
returns: True if (the client has quit/the socket is broken)
"""
return True
