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