def __init__(self,port=None): """:param port: The port on which the server should listen""" if port==None: port=config().getint("Metaserver","port") foamLogger("server").info("Starting Server up") self.pid=os.getpid() try: self.webserver = ServerProxy(WEBSERVER_RPCURL) self.servers={} self.dataLock=Lock() self.startupLock=Lock() self.collect() self.checker=MetaChecker(self) self.checker.setDaemon(True) self.checker.start() self._server=ServerBase(('',port),logRequests=False) self._server.register_instance(self) self._server.register_introspection_functions() self._server.serve_forever() # occasional errors with "Broken pipe" except KeyboardInterrupt: foamLogger("server").warning("Keyboard interrupt") except socket.error as reason: foamLogger("server").error("Socket Error: "+str(reason)) print_("Can't start server, Problem with socket: ",reason[1]) except: foamLogger("server").error("Unknown exception "+str(sys.exc_info()[0])) foamLogger("server").error(str(sys.exc_info()[1])) foamLogger("server").error("Traceback: "+str(extract_tb(sys.exc_info()[2])))
def __init__(self,run=None,master=None,lines=100): """ @param run: The thread that controls the run @param master: The Runner-Object that controls everything @param lines: the number of lines the server should remember """ Thread.__init__(self) self.isRegistered=False tries=0 maxTries=config().getint("Network","socketRetries") ok=False while not ok and tries<maxTries: ok=True tries+=1 self._port=findFreePort() self._running=False if self._port<0: foamLogger().warning("Could not get a free port. Server not started") return try: foamLogger().info("Serving on port %d" % self._port) self._server=ServerBase(('',self._port),logRequests=False) self._server.register_introspection_functions() self._answerer=FoamAnswerer(run=run,master=master,lines=lines,foamserver=self) self._server.register_instance(self._answerer) self._server.register_function(self.killServer) self._server.register_function(self.kill) if run: self._server.register_function(run.cpuTime) self._server.register_function(run.cpuUserTime) self._server.register_function(run.cpuSystemTime) self._server.register_function(run.wallTime) self._server.register_function(run.usedMemory) except socket.error: reason = sys.exc_info()[1] # compatible with 2.x and 3.x ok=False warning("Could not start on port",self._port,"althoug it was promised. Try:",tries,"of",maxTries) foamLogger().warning("Could not get port %d - SocketError: %s. Try %d of %d" % (self._port,str(reason),tries,maxTries)) sleep(2+20*random()) if not ok: foamLogger().warning("Exceeded maximum number of tries for getting a port: %d" % maxTries) warning("Did not get a port after %d tries" % tries) else: if tries>1: warning("Got a port after %d tries" % tries)
def __init__(self,run=None,master=None,lines=100): """ :param run: The thread that controls the run :param master: The Runner-Object that controls everything :param lines: the number of lines the server should remember """ Thread.__init__(self) self.isRegistered=False tries=0 maxTries=config().getint("Network","socketRetries") ok=False self._zConf=ZeroConfFoamServer() while not ok and tries<maxTries: ok=True tries+=1 self.__ssl,self._port=findFreePort() self._running=False if self._port<0: foamLogger().warning("Could not get a free port. Server not started") return try: foamLogger().info("Serving on port %d" % self._port) self._server=ServerBase(('',self._port),useSSL=self.__ssl,logRequests=False) self.__ssl=self._server.useSSL self._server.register_introspection_functions() self._answerer=FoamAnswerer(run=run,master=master,lines=lines,foamserver=self) self._server.register_instance(self._answerer) self._server.register_function(self.killServer) self._server.register_function(self.kill) if run: self._server.register_function(run.cpuTime) self._server.register_function(run.cpuUserTime) self._server.register_function(run.cpuSystemTime) self._server.register_function(run.wallTime) self._server.register_function(run.usedMemory) except socket.error: reason = sys.exc_info()[1] # compatible with 2.x and 3.x ok=False warning("Could not start on port",self._port,"althoug it was promised. Try:",tries,"of",maxTries) foamLogger().warning("Could not get port %d - SocketError: %s. Try %d of %d" % (self._port,str(reason),tries,maxTries)) sleep(2+20*random()) if not ok: foamLogger().warning("Exceeded maximum number of tries for getting a port: %d" % maxTries) warning("Did not get a port after %d tries" % tries) else: if tries>1: warning("Got a port after %d tries" % tries)
class FoamMetaServer(object): """The Metaserver. Collects all the known FoamServers. Then waits for the servers to register themselves. Checks at regular intervalls whether the processes are still alive """ def __init__(self,port=None): """:param port: The port on which the server should listen""" if port==None: port=config().getint("Metaserver","port") foamLogger("server").info("Starting Server up") self.pid=os.getpid() try: self.webserver = ServerProxy(WEBSERVER_RPCURL) self.servers={} self.dataLock=Lock() self.startupLock=Lock() self.collect() self.checker=MetaChecker(self) self.checker.setDaemon(True) self.checker.start() self._server=ServerBase(('',port),logRequests=False) self._server.register_instance(self) self._server.register_introspection_functions() self._server.serve_forever() # occasional errors with "Broken pipe" except KeyboardInterrupt: foamLogger("server").warning("Keyboard interrupt") except socket.error as reason: foamLogger("server").error("Socket Error: "+str(reason)) print_("Can't start server, Problem with socket: ",reason[1]) except: foamLogger("server").error("Unknown exception "+str(sys.exc_info()[0])) foamLogger("server").error(str(sys.exc_info()[1])) foamLogger("server").error("Traceback: "+str(extract_tb(sys.exc_info()[2]))) def list(self): """Returns a list of the found Foam-Runs""" self.dataLock.acquire() servers=copy.deepcopy(self.servers) self.dataLock.release() result={} for idnum,info in servers.iteritems(): result[idnum]=info._info return result def collect(self): """Starts a thread that collects the data of the servers from the net""" collector=MetaCollector(self) collector.setDaemon(True) collector.start() return True def scan(self,additional): """Starts a thread that collects the data of the servers from the net :param additional: a string with a list of additional subnets that should be scanned""" collector=MetaCollector(self,additional=additional) collector.setDaemon(True) collector.start() return True def kill(self): """Exits the server""" foamLogger("server").warning("Terminating due to request") t=Timer(1.,self._suicide) t.start() return True def _suicide(self): """The server kills itself""" os.kill(self.pid,1) def registerServer(self,ip,pid,port,sync=True,external=False): """Registers a new server via XMLRPC :param ip: IP of the server :param pid: Die PID at the server :param port: the port at which the server is listening :param sync: (optional) if to sync with the webserver or not """ return self._registerServer(ip,pid,port,sync=sync,external=True) def _registerServer(self,ip,pid,port,sync=True,external=False): """Registers a new server :param ip: IP of the server :param pid: Die PID at the server :param port: the port at which the server is listening :param external: was called via XMLRPC :param sync: (optional) if to sync with the webserver or not """ self.dataLock.acquire() serverID="%s:%d" % (ip,port) foamLogger("server").info("Registering: %s with PID: %d" % (serverID,pid)) insertServer=False try: if self.servers.has_key(serverID): # maybe it's another process server=getServerProxy(ip,port) gotPid=server.pid() if pid!=gotPid: self.servers.pop(serverID) foamLogger("server").warning("Server "+serverID+" changed PID from %d to %d" % (pid,gotPid)) insertServer=True else: foamLogger("server").warning("Server "+serverID+" already registered") else: insertServer=True if insertServer: new=ServerInfo(ip,pid,port) doIt=external if not doIt: doIt=new.checkValid() if doIt: new.queryData() # occasional errors with 'Connection refused' self.servers[serverID]=new foamLogger("server").debug("Inserted "+serverID) except: foamLogger("server").error("Registering Server "+serverID+" failed:"+str(sys.exc_info()[0])) foamLogger("server").error("Reason:"+str(sys.exc_info()[1])) foamLogger("server").error("Trace:"+str(extract_tb(sys.exc_info()[2]))) self.dataLock.release() if DO_WEBSYNC and insertServer and sync: foamLogger("server").info("Registering %s for webserver: %s" % (serverID,'new/%(ip)s/%(port)s/' % {'ip':ip, 'port':port})) try: self.webserver.new_process(ip, port) except: foamLogger("server").warning("Registering %s for webserver failed!" % (serverID)) return True def deregisterServer(self,ip,pid,port,sync=True): """Deregisters a server :param ip: IP of the server :param pid: Die PID at the server :param port: the port at which the server is listening :param sync: (optional) if to sync with the webserver or not """ self.dataLock.acquire() serverID="%s:%d" % (ip,port) foamLogger("server").info("Deregistering: %s with PID: %d" % (serverID,pid)) try: if self.servers.has_key(serverID): self.servers.pop(serverID) if DO_WEBSYNC and sync: foamLogger("server").info("Deregistering %s from webserver: %s" % (serverID,'end/%(ip)s/%(port)s/' % {'ip':ip, 'port':port})) try: self.webserver.end_process(ip, port) except: foamLogger("server").warning("Deregistering %s from webserver failed" % (serverID)) else: foamLogger("server").warning("Server "+serverID+" not registered") except: foamLogger("server").error("Deregistering Server "+serverID+" failed:"+str(sys.exc_info()[0])) foamLogger("server").error("Reason:"+str(sys.exc_info()[1])) foamLogger("server").error("Trace:"+str(extract_tb(sys.exc_info()[2]))) self.dataLock.release() return True def forwardCommand(self,ip,port,cmd): """Forwards a RPC to another machine :param ip: IP of the server :param port: the port at which the server is listening :param cmd: the command that should be executed there :return: the result of the command """ result="" try: server=getServerProxy(ip,port) result=eval("server."+cmd) foamLogger("server").debug("Forwarding to "+ip+"the command\""+cmd+"\" Result:"+str(result)) except Fault as reason: result="Fault: "+str(reason) except socket.error as reason: result="socket.error: "+str(reason) except TypeError as reason: result="Type error: ",reason except SyntaxError as reason: result="Syntax Error in:"+cmd if result==None: result="" return result
class FoamServer(Thread): """This is the class that serves the requests about the FOAM-Run""" def __init__(self,run=None,master=None,lines=100): """ @param run: The thread that controls the run @param master: The Runner-Object that controls everything @param lines: the number of lines the server should remember """ Thread.__init__(self) self.isRegistered=False tries=0 maxTries=config().getint("Network","socketRetries") ok=False while not ok and tries<maxTries: ok=True tries+=1 self._port=findFreePort() self._running=False if self._port<0: foamLogger().warning("Could not get a free port. Server not started") return try: foamLogger().info("Serving on port %d" % self._port) self._server=ServerBase(('',self._port),logRequests=False) self._server.register_introspection_functions() self._answerer=FoamAnswerer(run=run,master=master,lines=lines,foamserver=self) self._server.register_instance(self._answerer) self._server.register_function(self.killServer) self._server.register_function(self.kill) if run: self._server.register_function(run.cpuTime) self._server.register_function(run.cpuUserTime) self._server.register_function(run.cpuSystemTime) self._server.register_function(run.wallTime) self._server.register_function(run.usedMemory) except socket.error: reason = sys.exc_info()[1] # compatible with 2.x and 3.x ok=False warning("Could not start on port",self._port,"althoug it was promised. Try:",tries,"of",maxTries) foamLogger().warning("Could not get port %d - SocketError: %s. Try %d of %d" % (self._port,str(reason),tries,maxTries)) sleep(2+20*random()) if not ok: foamLogger().warning("Exceeded maximum number of tries for getting a port: %d" % maxTries) warning("Did not get a port after %d tries" % tries) else: if tries>1: warning("Got a port after %d tries" % tries) def run(self): foamLogger().info("Running server at port %d" % self._port) if self._port<0: return # wait befor registering to avoid timeouts reg=Timer(5.,self.register) reg.start() self._running=True try: while self._running: self._server.handle_request() except select.error: # This seems to be necessary since python 2.6 pass # self._server.serve_forever() # the old way self._server.server_close() foamLogger().warning("Stopped serving on port %d" % self._port) def info(self): """Returns the IP, the PID and the port of the server (as one tuple)""" return self._answerer.ip(),self._answerer.pid(),self._port def kill(self): """Interrupts the FOAM-process (and kills the server)""" self._answerer._kill() return self.killServer() def killServer(self): """Kills the server process""" tmp=self._running self._running=False return tmp def register(self): """Tries to register with the Meta-Server""" foamLogger().info("Trying to register as IP:%s PID:%d Port:%d" % (self._answerer.ip(), self._answerer.pid(),self._port)) try: try: meta=ServerProxy( "http://%s:%d" % (config().get( "Metaserver","ip"),config().getint("Metaserver","port"))) response=meta.registerServer(self._answerer.ip(), self._answerer.pid(),self._port) self.isRegistered=True foamLogger().info("Registered with server. Response " + str(response)) except socket.error: reason = sys.exc_info()[1] # compatible with 2.x and 3.x foamLogger().warning("Can't connect to meta-server - SocketError: "+str(reason)) except: foamLogger().error("Can't connect to meta-server - Unknown Error: "+str(sys.exc_info()[0])) foamLogger().error(str(sys.exc_info()[1])) foamLogger().error("Traceback: "+str(extract_tb(sys.exc_info()[2]))) except: # print "Error during registering (no socket module?)" pass def deregister(self): """Tries to deregister with the Meta-Server""" if self.isRegistered: try: meta=ServerProxy("http://%s:%d" % (config().get("Metaserver","ip"),config().getint("Metaserver","port"))) meta.deregisterServer(self._answerer.ip(),self._answerer.pid(),self._port) except socket.error: reason = sys.exc_info()[1] # compatible with 2.x and 3.x foamLogger().warning("Can't connect to meta-server - SocketError: "+str(reason)) except: foamLogger().error("Can't connect to meta-server - Unknown Error: "+str(sys.exc_info()[0])) foamLogger().error(str(sys.exc_info()[1])) foamLogger().error("Traceback: "+str(extract_tb(sys.exc_info()[2]))) else: foamLogger().warning("Not deregistering, because it seems we were not registered in the first place ") self._server.server_close() def _insertLine(self,line): """Inserts a new line, not to be called via XMLRPC""" self._answerer._insertLine(line)
class FoamServer(Thread): """This is the class that serves the requests about the FOAM-Run""" def __init__(self, run=None, master=None, lines=100): """ :param run: The thread that controls the run :param master: The Runner-Object that controls everything :param lines: the number of lines the server should remember """ Thread.__init__(self) self.isRegistered = False tries = 0 maxTries = config().getint("Network", "socketRetries") ok = False while not ok and tries < maxTries: ok = True tries += 1 self._port = findFreePort() self._running = False if self._port < 0: foamLogger().warning( "Could not get a free port. Server not started") return try: foamLogger().info("Serving on port %d" % self._port) self._server = ServerBase(('', self._port), logRequests=False) self._server.register_introspection_functions() self._answerer = FoamAnswerer(run=run, master=master, lines=lines, foamserver=self) self._server.register_instance(self._answerer) self._server.register_function(self.killServer) self._server.register_function(self.kill) if run: self._server.register_function(run.cpuTime) self._server.register_function(run.cpuUserTime) self._server.register_function(run.cpuSystemTime) self._server.register_function(run.wallTime) self._server.register_function(run.usedMemory) except socket.error: reason = sys.exc_info()[1] # compatible with 2.x and 3.x ok = False warning("Could not start on port", self._port, "althoug it was promised. Try:", tries, "of", maxTries) foamLogger().warning( "Could not get port %d - SocketError: %s. Try %d of %d" % (self._port, str(reason), tries, maxTries)) sleep(2 + 20 * random()) if not ok: foamLogger().warning( "Exceeded maximum number of tries for getting a port: %d" % maxTries) warning("Did not get a port after %d tries" % tries) else: if tries > 1: warning("Got a port after %d tries" % tries) def run(self): foamLogger().info("Running server at port %d" % self._port) if self._port < 0: return # wait befor registering to avoid timeouts reg = Timer(5., self.register) reg.start() self._running = True try: while self._running: self._server.handle_request() except select.error: # This seems to be necessary since python 2.6 pass # self._server.serve_forever() # the old way self._server.server_close() foamLogger().warning("Stopped serving on port %d" % self._port) def info(self): """Returns the IP, the PID and the port of the server (as one tuple)""" return self._answerer.ip(), self._answerer.pid(), self._port def kill(self): """Interrupts the FOAM-process (and kills the server)""" self._answerer._kill() return self.killServer() def killServer(self): """Kills the server process""" tmp = self._running self._running = False return tmp def register(self): """Tries to register with the Meta-Server""" foamLogger().info( "Trying to register as IP:%s PID:%d Port:%d" % (self._answerer.ip(), self._answerer.pid(), self._port)) try: try: meta = ServerProxy("http://%s:%d" % (config().get("Metaserver", "ip"), config().getint("Metaserver", "port"))) response = meta.registerServer(self._answerer.ip(), self._answerer.pid(), self._port) self.isRegistered = True foamLogger().info("Registered with server. Response " + str(response)) except socket.error: reason = sys.exc_info()[1] # compatible with 2.x and 3.x foamLogger().warning( "Can't connect to meta-server - SocketError: " + str(reason)) except: foamLogger().error( "Can't connect to meta-server - Unknown Error: " + str(sys.exc_info()[0])) foamLogger().error(str(sys.exc_info()[1])) foamLogger().error("Traceback: " + str(extract_tb(sys.exc_info()[2]))) except: # print "Error during registering (no socket module?)" pass def deregister(self): """Tries to deregister with the Meta-Server""" if self.isRegistered: try: meta = ServerProxy("http://%s:%d" % (config().get("Metaserver", "ip"), config().getint("Metaserver", "port"))) meta.deregisterServer(self._answerer.ip(), self._answerer.pid(), self._port) except socket.error: reason = sys.exc_info()[1] # compatible with 2.x and 3.x foamLogger().warning( "Can't connect to meta-server - SocketError: " + str(reason)) except: foamLogger().error( "Can't connect to meta-server - Unknown Error: " + str(sys.exc_info()[0])) foamLogger().error(str(sys.exc_info()[1])) foamLogger().error("Traceback: " + str(extract_tb(sys.exc_info()[2]))) else: foamLogger().warning( "Not deregistering, because it seems we were not registered in the first place " ) self._server.server_close() def _insertLine(self, line): """Inserts a new line, not to be called via XMLRPC""" self._answerer._insertLine(line)