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)