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 ask(self, what, data=None):
"""
what should already be a list with message and params
"""
self._lock.acquire()
try:
if not self._connected:
# TODO: move this to a method
# stablish connecton
self._socket = RequestSocket(None)
self.debug(2, "urlParams: %s %s" % self._url.getParams())
self._socket.connect(self._url.getParams())
self.debug(
1, "created Client socket w/ fd %d to %s" %
(self._socket.fileno(), self._url))
# throw away the greeting
ans = self.read()
self._connected = True
# identify ourselves so the server knows what are we.
self.ident()
if not type(what) == ListType:
self.debug(1, "what's not a list!: %s" % str(what))
self.write(what, data)
data = self.read()
self._lock.release()
if not data == None:
return data
else:
self.debug(1, "dead!: closed")
self._dead = True
self.close()
raise UmbDead
# other errors?
except (ValueError, IOError, error), e:
self.debug(1, "dead!: %s" % e)
self._dead = True
self._lock.release()
self.close()
raise UmbDead
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 ask (self, what, data=None):
"""
what should already be a list with message and params
"""
self._lock.acquire ()
try:
if not self._connected:
# TODO: move this to a method
# stablish connecton
self._socket= RequestSocket (None)
self.debug (2, "urlParams: %s %s" % self._url.getParams ())
self._socket.connect (self._url.getParams ())
self.debug (1, "created Client socket w/ fd %d to %s" % (self._socket.fileno (), self._url))
# throw away the greeting
ans= self.read ()
self._connected= True
# identify ourselves so the server knows what are we.
self.ident ()
if not type (what)==ListType:
self.debug (1, "what's not a list!: %s" % str (what))
self.write (what, data)
data= self.read ()
self._lock.release ()
if not data==None:
return data
else:
self.debug (1, "dead!: closed")
self._dead= True
self.close ()
raise UmbDead
# other errors?
except (ValueError, IOError, error), e:
self.debug (1, "dead!: %s" % e)
self._dead= True
self._lock.release ()
self.close ()
raise UmbDead
class Client(Object):
"""
generic client
it's blocking. 'not responding, still trying'?
"""
def __init__(self, url, master=None):
Object.__init__(self)
self.debug(1, "Client: %s" % (url))
self._url = URL(url)
self._dead = False
self._connected = False
self._lock = RLock()
self._socket = None
self._master = master
def __del__(self):
try:
self.close()
except:
# just in case __init__ didn't run completely
pass
def url(self):
return self._url
def ident(self):
data = self._socket.getSockName()
self.write(["i am", "virtue://%s:%d/" % data])
ans = self.read()
def read(self):
return self._socket.read()
def readData(self, size):
return self._socket.readData(size)
def write(self, what, data=None):
self._socket.write(what, data)
def writeData(self, data):
return self._socket.writeData(data)
def ask(self, what, data=None):
"""
what should already be a list with message and params
"""
self._lock.acquire()
try:
if not self._connected:
# TODO: move this to a method
# stablish connecton
self._socket = RequestSocket(None)
self.debug(2, "urlParams: %s %s" % self._url.getParams())
self._socket.connect(self._url.getParams())
self.debug(
1, "created Client socket w/ fd %d to %s" %
(self._socket.fileno(), self._url))
# throw away the greeting
ans = self.read()
self._connected = True
# identify ourselves so the server knows what are we.
self.ident()
if not type(what) == ListType:
self.debug(1, "what's not a list!: %s" % str(what))
self.write(what, data)
data = self.read()
self._lock.release()
if not data == None:
return data
else:
self.debug(1, "dead!: closed")
self._dead = True
self.close()
raise UmbDead
# other errors?
except (ValueError, IOError, error), e:
self.debug(1, "dead!: %s" % e)
self._dead = True
self._lock.release()
self.close()
raise UmbDead
class Client (Object):
"""
generic client
it's blocking. 'not responding, still trying'?
"""
def __init__ (self, url, master=None):
Object.__init__ (self)
self.debug (1, "Client: %s" % (url))
self._url= URL (url)
self._dead= False
self._connected= False
self._lock= RLock ()
self._socket= None
self._master= master
def __del__ (self):
try:
self.close ()
except:
# just in case __init__ didn't run completely
pass
def url (self):
return self._url
def ident (self):
data= self._socket.getSockName ()
self.write (["i am", "virtue://%s:%d/" % data])
ans= self.read ()
def read (self):
return self._socket.read ()
def readData (self, size):
return self._socket.readData (size)
def write (self, what, data=None):
self._socket.write (what, data)
def writeData (self, data):
return self._socket.writeData (data)
def ask (self, what, data=None):
"""
what should already be a list with message and params
"""
self._lock.acquire ()
try:
if not self._connected:
# TODO: move this to a method
# stablish connecton
self._socket= RequestSocket (None)
self.debug (2, "urlParams: %s %s" % self._url.getParams ())
self._socket.connect (self._url.getParams ())
self.debug (1, "created Client socket w/ fd %d to %s" % (self._socket.fileno (), self._url))
# throw away the greeting
ans= self.read ()
self._connected= True
# identify ourselves so the server knows what are we.
self.ident ()
if not type (what)==ListType:
self.debug (1, "what's not a list!: %s" % str (what))
self.write (what, data)
data= self.read ()
self._lock.release ()
if not data==None:
return data
else:
self.debug (1, "dead!: closed")
self._dead= True
self.close ()
raise UmbDead
# other errors?
except (ValueError, IOError, error), e:
self.debug (1, "dead!: %s" % e)
self._dead= True
self._lock.release ()
self.close ()
raise UmbDead
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
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
