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 run(self):
foamLogger("server").info("Checker starting")
while True:
self.parent.startupLock.acquire()
foamLogger("server").debug("Start Checking")
self.parent.dataLock.acquire()
servers=copy.deepcopy(self.parent.servers)
self.parent.dataLock.release()
for key,obj in servers.iteritems():
isOK=obj.checkValid()
if not isOK:
foamLogger("server").info("Server "+key+" not OK. Deregistering")
self.parent.deregisterServer(obj["ip"],obj["pid"],obj["port"])
elif DO_WEBSYNC:
if not self.syncTimes.has_key(key):
self.syncTimes[key]=self.sleepTime
if self.syncTimes[key] >= WEBSYNC_INTERVAL:
self.syncTimes[key]=self.sleepTime
foamLogger("server").debug("Refreshing "+key+" on Webserver")
try:
self.parent.webserver.refresh(obj['ip'], obj['port'])
except socket.timeout, e:
pass
except:
foamLogger("server").warning("Unknown exception "+str(sys.exc_info()[0])+" while syncing with webserver %s" % (WEBSERVER_RPCURL))
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
def read(self,fh):
"""reads the next line
fh - filehandle to read from
Return value: False if the end of the file was reached. True
otherwise"""
if not self.goOn:
return False
try:
self.line=fh.readline()
if PY3:
if type(self.line) is bytes:
self.line=self.line.decode()
self.bytes+=len(self.line)
except KeyboardInterrupt:
e=sys.exc_info()[1]
foamLogger().warning("Keyboard Interrupt")
print_(" Interrupted by the Keyboard")
self.wasInterupted=True
self.goOn=False
self.line=""
return False
if len(self.line)>0:
status=True
else:
status=False
self.line=self.line.strip()
return status
# Should work with Python3 and Python2
def run(self):
foamLogger("server").info("Checker starting")
while True:
self.parent.startupLock.acquire()
foamLogger("server").debug("Start Checking")
self.parent.dataLock.acquire()
servers=copy.deepcopy(self.parent.servers)
self.parent.dataLock.release()
for key,obj in servers.iteritems():
isOK=obj.checkValid()
if not isOK:
foamLogger("server").info("Server "+key+" not OK. Deregistering")
self.parent.deregisterServer(obj["ip"],obj["pid"],obj["port"])
elif DO_WEBSYNC:
if not self.syncTimes.has_key(key):
self.syncTimes[key]=self.sleepTime
if self.syncTimes[key] >= WEBSYNC_INTERVAL:
self.syncTimes[key]=self.sleepTime
foamLogger("server").debug("Refreshing "+key+" on Webserver")
try:
self.parent.webserver.refresh(obj['ip'], obj['port'])
except socket.timeout, e:
pass
except:
foamLogger("server").warning("Unknown exception "+str(sys.exc_info()[0])+" while syncing with webserver %s" % (WEBSERVER_RPCURL))
def read(self,fh):
"""reads the next line
fh - filehandle to read from
Return value: False if the end of the file was reached. True
otherwise"""
if not self.goOn:
return False
try:
self.line=fh.readline()
if PY3:
if type(self.line) is bytes:
self.line=self.line.decode()
self.bytes+=len(self.line)
except KeyboardInterrupt:
e=sys.exc_info()[1]
foamLogger().warning("Keyboard Interrupt")
print_(" Interrupted by the Keyboard")
self.wasInterupted=True
self.goOn=False
self.line=""
return False
if len(self.line)>0:
status=True
else:
status=False
self.line=self.line.strip()
return status
# Should work with Python3 and Python2
def run(self):
"""start the command"""
# print "Starting ",self.cmdline
self.resStart=getrusage(self.who)
self.timeStart=time()
if sys.version_info<(2,4):
run=Popen4(self.cmdline)
self.output=run.fromchild
else:
run=subprocess.Popen(shellExecutionPrefix()+self.cmdline,
shell=True,
bufsize=0,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
close_fds=True)
self.output=run.stdout
self.run=run
self.threadPid=run.pid
foamLogger().info("Started with PID %d" % self.threadPid)
if self.isLinux:
# print "Starting Timer"
self.timer=Timer(0.1*self.timerTime,getLinuxMem,args=[self])
self.timer.start()
# print "Starting Timer"
self.timer2=Timer(0.5*self.timerTime,checkForStopFile,args=[self])
self.timer2.start()
self.hasSomethingToSay=True
self.stateLock.release()
try:
# print "Waiting",time()
self.status=run.wait()
# Python 2.3 on Mac OS X never seems to reach this point
# print "After wait",time()
# print "Status:",self.status
# to give a chance to read the remaining output
if self.hasSomethingToSay:
sleep(2.)
while self.reader.read(self.output):
print_("Unused output:",self.reader.line)
except OSError:
e = sys.exc_info()[1] # compatible with 2.x and 3.x
print_("Exeption caught:",e)
self.stopTimer()
self.threadPid=-1
self.resEnd=getrusage(self.who)
self.timeEnd=time()
# print "End:",self.timeEnd
# print "Returned",self.status
self.getReturnCode()
def run(self):
"""start the command"""
# print "Starting ",self.cmdline
self.resStart=getrusage(self.who)
self.timeStart=time()
if sys.version_info<(2,4):
run=Popen4(self.cmdline)
self.output=run.fromchild
else:
run=subprocess.Popen(shellExecutionPrefix()+self.cmdline,
shell=True,
bufsize=0,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
close_fds=True)
self.output=run.stdout
self.run=run
self.threadPid=run.pid
foamLogger().info("Started with PID %d" % self.threadPid)
if self.isLinux:
# print "Starting Timer"
self.timer=Timer(0.1*self.timerTime,getLinuxMem,args=[self])
self.timer.start()
# print "Starting Timer"
self.timer2=Timer(0.5*self.timerTime,checkForStopFile,args=[self])
self.timer2.start()
self.hasSomethingToSay=True
self.stateLock.release()
try:
# print "Waiting",time()
self.status=run.wait()
# Python 2.3 on Mac OS X never seems to reach this point
# print "After wait",time()
# print "Status:",self.status
# to give a chance to read the remaining output
if self.hasSomethingToSay:
sleep(2.)
while self.reader.read(self.output):
print_("Unused output:",self.reader.line)
except OSError:
e = sys.exc_info()[1] # compatible with 2.x and 3.x
print_("Exeption caught:",e)
self.stopTimer()
self.threadPid=-1
self.resEnd=getrusage(self.who)
self.timeEnd=time()
# print "End:",self.timeEnd
# print "Returned",self.status
self.getReturnCode()
def _kill(self):
"""Interrupts the FOAM-process"""
if self._run:
foamLogger().warning("Killed by request")
self._run.interrupt()
return True
else:
return False
def _kill(self):
"""Interrupts the FOAM-process"""
if self._run:
foamLogger().warning("Killed by request")
self._run.interrupt()
return True
else:
return False
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:
foamLogger().warning("Can't connect to meta-server - SocketError: "+str(reason))
except:
def checkValid(self):
"""Check with server whether this data item is still valid"""
result=False
foamLogger("server").debug("Checking "+self["ip"]+"@"+str(self["port"]))
try:
server=xmlrpclib.ServerProxy("http://%s:%d" % (self["ip"],self["port"]))
pid=server.pid()
if pid==self["pid"]:
result=True
except socket.timeout,reason:
foamLogger("server").info(self["ip"]+"@"+str(self["port"])+" seems to be dead")
def checkValid(self):
"""Check with server whether this data item is still valid"""
result=False
foamLogger("server").debug("Checking "+self["ip"]+"@"+str(self["port"]))
try:
server=xmlrpclib.ServerProxy("http://%s:%d" % (self["ip"],self["port"]))
pid=server.pid()
if pid==self["pid"]:
result=True
except socket.timeout,reason:
foamLogger("server").info(self["ip"]+"@"+str(self["port"])+" seems to be dead")
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=xmlrpclib.ServerProxy("http://%s:%d" % (ip,port))
result=eval("server."+cmd)
foamLogger("server").debug("Forwarding to "+ip+"the command\""+cmd+"\" Result:"+str(result))
except xmlrpclib.Fault,reason:
result="xmlrpclib.Fault: "+str(reason)
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=xmlrpclib.ServerProxy("http://%s:%d" % (ip,port))
result=eval("server."+cmd)
foamLogger("server").debug("Forwarding to "+ip+"the command\""+cmd+"\" Result:"+str(result))
except xmlrpclib.Fault,reason:
result="xmlrpclib.Fault: "+str(reason)
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)
def setState(self,state):
"""sets the state of the thread (is there any more output)"""
self.stateLock.acquire()
self.hasSomethingToSay=state
if not self.hasSomethingToSay and self.timeStart and self.reader.wasInterupted:
if self.threadPid>0:
msg="Killing PID %d" % self.threadPid
print_(msg)
foamLogger().warning(msg)
try:
kill(self.threadPid,signal.SIGKILL)
except OSError:
warning("Process",self.threadPid,"was already dead")
# print "Set: ",state
self.stateLock.release()
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,e:
# This seems to be necessary since python 2.6
pass
def setState(self,state):
"""sets the state of the thread (is there any more output)"""
self.stateLock.acquire()
self.hasSomethingToSay=state
if not self.hasSomethingToSay and self.timeStart and self.reader.wasInterupted:
if self.threadPid>0:
msg="Killing PID %d" % self.threadPid
print msg
foamLogger().warning(msg)
try:
kill(self.threadPid,signal.SIGKILL)
except OSError:
warning("Process",self.threadPid,"was already dead")
# print "Set: ",state
self.stateLock.release()
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 __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 read(self,fh):
"""reads the next line
fh - filehandle to read from
Return value: False if the end of the file was reached. True
otherwise"""
if not self.goOn:
return False
try:
self.line=fh.readline()
self.bytes+=len(self.line)
except KeyboardInterrupt,e:
foamLogger().warning("Keyboard Interrupt")
print " Interrupted by the Keyboard"
self.wasInterupted=True
self.goOn=False
self.line=""
return False
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 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 __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 = xmlrpclib.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,reason:
foamLogger("server").error("Socket Error: "+str(reason))
print "Can't start server, Problem with socket: ",reason[1]
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 = xmlrpclib.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,reason:
foamLogger("server").error("Socket Error: "+str(reason))
print "Can't start server, Problem with socket: ",reason[1]
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=length=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:
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())
def start(self):
"""starts the command and stays with it till the end"""
self.started = True
if not self.noLog:
if self.compressLog:
fh = gzip.open(self.logFile, "w")
else:
fh = open(self.logFile, "w")
self.startHandle()
self.writeStartTime()
self.writeTheState("Running")
check = BasicRunnerCheck()
if self.echoCommandLine:
print_(self.echoCommandLine + " " + " ".join(self.argv))
self.run.start()
interrupted = False
totalWarningLines = 0
addLinesToWarning = 0
collectWarnings = True
while self.run.check():
try:
self.run.read()
if not self.run.check():
break
line = self.run.getLine()
if "errorText" in self.data:
self.data["errorText"] += line + "\n"
if addLinesToWarning > 0:
self.data["warningText"] += line + "\n"
addLinesToWarning -= 1
totalWarningLines += 1
if totalWarningLines > 500:
collectWarnings = False
addLinesToWarning = 0
self.data[
"warningText"] += "No more warnings added because limit of 500 lines exceeded"
self.data["lines"] += 1
self.lastLogLineSeen = time()
self.writeLastSeen()
tmp = check.getTime(line)
if check.controlDictRead(line):
if self.writeRequested:
duration = config().getfloat("Execution",
"controlDictRestoreWait",
default=30.)
warning(
"Preparing to reset controlDict to old glory in",
duration, "seconds")
Timer(duration,
restoreControlDict,
args=[self.controlDict, self]).start()
self.writeRequested = False
if tmp != None:
self.data["time"] = tmp
self.nowTime = tmp
self.writeTheState("Running", always=False)
self.writeNowTime()
self.lastTimeStepSeen = time()
if self.createTime == None:
# necessary because interFoam reports no creation time
self.createTime = tmp
try:
self.data["stepNr"] += 1
except KeyError:
self.data["stepNr"] = 1 # =1L
self.data["lasttimesteptime"] = asctime()
tmp = check.getCreateTime(line)
self.endSeen = check.endSeen
if tmp != None:
self.createTime = tmp
if not self.silent:
try:
print_(line)
except IOError:
e = sys.exc_info()[1] # compatible with 2.x and 3.x
if e.errno != 32:
raise e
else:
# Pipe was broken
self.run.interrupt()
if line.find("FOAM FATAL ERROR") >= 0 or line.find(
"FOAM FATAL IO ERROR") >= 0:
self.fatalError = True
self.data["errorText"] = "PyFoam found a Fatal Error "
if "time" in self.data:
self.data["errorText"] += "at time " + str(
self.data["time"]) + "\n"
else:
self.data["errorText"] += "before time started\n"
self.data["errorText"] += "\n" + line + "\n"
if line.find("Foam::sigFpe::sigFpeHandler") >= 0:
self.fatalFPE = True
if line.find("Foam::error::printStack") >= 0:
self.fatalStackdump = True
if self.fatalError and line != "":
foamLogger().error(line)
if line.find("FOAM Warning") >= 0:
self.warnings += 1
try:
self.data["warnings"] += 1
except KeyError:
self.data["warnings"] = 1
if collectWarnings:
addLinesToWarning = 20
if not "warningText" in self.data:
self.data["warningText"] = ""
else:
self.data["warningText"] += ("-" * 40) + "\n"
self.data[
"warningText"] += "Warning found by PyFoam on line "
self.data["warningText"] += str(
self.data["lines"]) + " "
if "time" in self.data:
self.data["warningText"] += "at time " + str(
self.data["time"]) + "\n"
else:
self.data["warningText"] += "before time started\n"
self.data["warningText"] += "\n" + line + "\n"
if self.server != None:
self.server._insertLine(line)
self.lineHandle(line)
if not self.noLog:
fh.write(line + "\n")
fh.flush()
elif self.logTail:
self.appendTailLine(line)
except KeyboardInterrupt:
e = sys.exc_info()[1] # compatible with 2.x and 3.x
foamLogger().warning("Keyboard Interrupt")
self.run.interrupt()
self.writeTheState("Interrupted")
self.data["keyboardInterrupt"] = True
interrupted = True
if not "keyboardInterrupt" in self.data:
self.data["keyboardInterrupt"] = self.run.keyboardInterupted
self.data["interrupted"] = interrupted
self.data["OK"] = self.runOK()
self.data["endSeen"] = self.endSeen
self.data["cpuTime"] = self.run.cpuTime()
self.data["cpuUserTime"] = self.run.cpuUserTime()
self.data["cpuSystemTime"] = self.run.cpuSystemTime()
self.data["wallTime"] = self.run.wallTime()
self.data["usedMemory"] = self.run.usedMemory()
self.data["endtime"] = asctime()
self.data["fatalError"] = self.fatalError
self.data["fatalFPE"] = self.fatalFPE
self.data["fatalStackdump"] = self.fatalStackdump
self.writeNowTime(force=True)
self.stopHandle()
if not interrupted:
if self.endSeen:
self.writeTheState("Finished - Ended")
else:
self.writeTheState("Finished")
for t in self.endTriggers:
t()
if not self.noLog:
fh.close()
elif self.logTail:
self.writeTailLog()
if self.server != None:
self.server.deregister()
self.server.kill()
foamLogger().info("Finished")
return self.data
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 __init__(self,
argv=None,
silent=False,
logname=None,
compressLog=False,
lam=None,
server=False,
restart=False,
noLog=False,
logTail=None,
remark=None,
jobId=None,
parameters=None,
writeState=True,
echoCommandLine=None):
"""@param argv: list with the tokens that are the command line
if not set the standard command line is used
@param silent: if True no output is sent to stdout
@param logname: name of the logfile
@param compressLog: Compress the logfile into a gzip
@param lam: Information about a parallel run
@param server: Whether or not to start the network-server
@type lam: PyFoam.Execution.ParallelExecution.LAMMachine
@param noLog: Don't output a log file
@param logTail: only the last lines of the log should be written
@param remark: User defined remark about the job
@param parameters: User defined dictionary with parameters for
documentation purposes
@param jobId: Job ID of the controlling system (Queueing system)
@param writeState: Write the state to some files in the case
@param echoCommandLine: Prefix that is printed with the command line. If unset nothing is printed
"""
if sys.version_info < (2,3):
# Python 2.2 does not have the capabilities for the Server-Thread
if server:
warning("Can not start server-process because Python-Version is too old")
server=False
if argv==None:
self.argv=sys.argv[1:]
else:
self.argv=argv
if oldApp():
self.dir=path.join(self.argv[1],self.argv[2])
if self.argv[2][-1]==path.sep:
self.argv[2]=self.argv[2][:-1]
else:
self.dir=path.curdir
if "-case" in self.argv:
self.dir=self.argv[self.argv.index("-case")+1]
if logname==None:
logname="PyFoam."+path.basename(argv[0])
try:
sol=self.getSolutionDirectory()
except OSError:
e = sys.exc_info()[1] # compatible with 2.x and 3.x
error("Solution directory",self.dir,"does not exist. No use running. Problem:",e)
self.echoCommandLine=echoCommandLine
self.silent=silent
self.lam=lam
self.origArgv=self.argv
self.writeState=writeState
self.__lastLastSeenWrite=0
self.__lastNowTimeWrite=0
if self.lam!=None:
self.argv=lam.buildMPIrun(self.argv)
if config().getdebug("ParallelExecution"):
debug("Command line:"," ".join(self.argv))
self.cmd=" ".join(self.argv)
foamLogger().info("Starting: "+self.cmd+" in "+path.abspath(path.curdir))
self.logFile=path.join(self.dir,logname+".logfile")
self.noLog=noLog
self.logTail=logTail
if self.logTail:
if self.noLog:
warning("Log tail",self.logTail,"and no-log specified. Using logTail")
self.noLog=True
self.lastLines=[]
self.compressLog=compressLog
if self.compressLog:
self.logFile+=".gz"
self.fatalError=False
self.fatalFPE=False
self.fatalStackdump=False
self.warnings=0
self.started=False
self.isRestarted=False
if restart:
self.controlDict=ParameterFile(path.join(self.dir,"system","controlDict"),backup=True)
self.controlDict.replaceParameter("startFrom","latestTime")
self.isRestarted=True
else:
self.controlDict=None
self.run=FoamThread(self.cmd,self)
self.server=None
if server:
self.server=FoamServer(run=self.run,master=self)
self.server.setDaemon(True)
self.server.start()
try:
IP,PID,Port=self.server.info()
f=open(path.join(self.dir,"PyFoamServer.info"),"w")
print_(IP,PID,Port,file=f)
f.close()
except AttributeError:
warning("There seems to be a problem with starting the server:",self.server,"with attributes",dir(self.server))
self.server=None
self.createTime=None
self.nowTime=None
self.startTimestamp=time()
self.stopMe=False
self.writeRequested=False
self.endTriggers=[]
self.lastLogLineSeen=None
self.lastTimeStepSeen=None
self.remark=remark
self.jobId=jobId
self.data={"lines":0} # self.data={"lines":0L}
self.data["logfile"]=self.logFile
self.data["casefullname"]=path.abspath(self.dir)
self.data["casename"]=path.basename(path.abspath(self.dir))
self.data["solver"]=path.basename(self.argv[0])
self.data["solverFull"]=self.argv[0]
self.data["commandLine"]=self.cmd
self.data["hostname"]=uname()[1]
if remark:
self.data["remark"]=remark
else:
self.data["remark"]="No remark given"
if jobId:
self.data["jobId"]=jobId
parameterFile=sol.getParametersFromFile()
if len(parameterFile):
self.data["parameters"]={}
for k,v in parameterFile.items():
self.data["parameters"][k]=makePrimitiveString(v)
if parameters:
if "parameters" not in self.data:
self.data["parameters"]={}
self.data["parameters"].update(parameters)
self.data["starttime"]=asctime()
from PyFoam.Infrastructure.Logging import foamLogger
from time import sleep
import sys
repeats=0
if len(sys.argv)>1:
name=sys.argv[1]
repeats=10
else:
name="nix"
if len(sys.argv)>2:
repeats=int(sys.argv[2])
foamLogger().warning("Starting Test")
foamLogger("test").info("info")
foamLogger("test").debug("debug vorher")
foamLogger("test").setLevel(1)
foamLogger("test").debug("debug nachher")
for i in range(repeats):
foamLogger("test").info("I am %s: count %d" % (name,i))
sleep(1)
foamLogger("test").info("finishing "+name)
foamLogger().warning("Ending Test")
def run(self):
self.parent.startupLock.acquire()
foamLogger("server").info("Collector starting")
if DO_WEBSYNC:
foamLogger("server").info("Get Processes from Webserver")
try:
webserver = ServerProxy(WEBSERVER_RPCURL)
for ip,port,pid in webserver.running_processes():
port = int(port)
try:
server=getServerProxy(ip,port)
pid=server.pid() # occasional errors with 'Connection refused'
self.parent._registerServer(ip,pid,port,sync=False)
except:
foamLogger("server").error("Unknown exception "+str(sys.exc_info()[0])+" while registering %s:%s" % (ip, port))
foamLogger("server").error("Reason:"+str(sys.exc_info()[1]))
foamLogger("server").error("Trace:"+str(extract_tb(sys.exc_info()[2])))
except:
foamLogger("server").warning("Unknown exception "+str(sys.exc_info()[0])+" while syncing with webserver %s" % (WEBSERVER_RPCURL))
port=config().getint("Network","startServerPort")
length=config().getint("Network","nrServerPorts")
machines=config().get("Metaserver","searchservers")
addreses=machines.split(',')
if self.additional!=None:
addreses=self.additional.split(',')+addreses
for a in addreses:
foamLogger("server").info("Collecting in subnet "+a)
for host in IP(a):
try:
name,alias,rest =socket.gethostbyaddr(str(host))
except socket.herror as reason:
# no name for the host
name="unknown"
foamLogger("server").debug("Collector Checking:"+str(host)+" "+name)
result=None
try:
result=checkFoamServers(str(host),port,length)
except:
foamLogger("server").error("Unknown exception "+str(sys.exc_info()[0])+" while checking for new servers"+str((str(host),port,length)))
foamLogger("server").error("Reason:"+str(sys.exc_info()[1]))
foamLogger("server").error("Trace:"+str(extract_tb(sys.exc_info()[2])))
if result!=None:
foamLogger("server").debug("Collector Found "+str(result)+" for "+name)
for p in result:
try:
server=getServerProxy(str(host),p)
ip=server.ip()
pid=server.pid()
self.parent._registerServer(ip,pid,p)
except:
foamLogger("server").error("Unknown exception "+str(sys.exc_info()[0])+" while registering "+name)
foamLogger("server").error("Reason:"+str(sys.exc_info()[1]))
foamLogger("server").error("Trace:"+str(extract_tb(sys.exc_info()[2])))
else:
foamLogger("server").debug("Collector Found "+str(result)+" for "+name)
self.parent.startupLock.release()
foamLogger("server").info("Collector finished")
from PyFoam.Infrastructure.Logging import foamLogger
from time import sleep
import sys
repeats = 0
if len(sys.argv) > 1:
name = sys.argv[1]
repeats = 10
else:
name = "nix"
if len(sys.argv) > 2:
repeats = int(sys.argv[2])
foamLogger().warning("Starting Test")
foamLogger("test").info("info")
foamLogger("test").debug("debug vorher")
foamLogger("test").setLevel(1)
foamLogger("test").debug("debug nachher")
for i in range(repeats):
foamLogger("test").info("I am %s: count %d" % (name, i))
sleep(1)
foamLogger("test").info("finishing " + name)
foamLogger().warning("Ending Test")
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 __init__(self,
argv=None,
silent=False,
logname=None,
compressLog=False,
lam=None,
server=False,
restart=False,
noLog=False,
logTail=None,
remark=None,
jobId=None,
parameters=None,
writeState=True,
echoCommandLine=None):
""":param argv: list with the tokens that are the command line
if not set the standard command line is used
:param silent: if True no output is sent to stdout
:param logname: name of the logfile
:param compressLog: Compress the logfile into a gzip
:param lam: Information about a parallel run
:param server: Whether or not to start the network-server
:type lam: PyFoam.Execution.ParallelExecution.LAMMachine
:param noLog: Don't output a log file
:param logTail: only the last lines of the log should be written
:param remark: User defined remark about the job
:param parameters: User defined dictionary with parameters for
documentation purposes
:param jobId: Job ID of the controlling system (Queueing system)
:param writeState: Write the state to some files in the case
:param echoCommandLine: Prefix that is printed with the command line. If unset nothing is printed
"""
if sys.version_info < (2, 3):
# Python 2.2 does not have the capabilities for the Server-Thread
if server:
warning(
"Can not start server-process because Python-Version is too old"
)
server = False
if argv == None:
self.argv = sys.argv[1:]
else:
self.argv = argv
if oldApp():
self.dir = path.join(self.argv[1], self.argv[2])
if self.argv[2][-1] == path.sep:
self.argv[2] = self.argv[2][:-1]
else:
self.dir = path.curdir
if "-case" in self.argv:
self.dir = self.argv[self.argv.index("-case") + 1]
logname = calcLogname(logname, argv)
try:
sol = self.getSolutionDirectory()
except OSError:
e = sys.exc_info()[1] # compatible with 2.x and 3.x
error("Solution directory", self.dir,
"does not exist. No use running. Problem:", e)
self.echoCommandLine = echoCommandLine
self.silent = silent
self.lam = lam
self.origArgv = self.argv
self.writeState = writeState
self.__lastLastSeenWrite = 0
self.__lastNowTimeWrite = 0
if self.lam != None:
self.argv = lam.buildMPIrun(self.argv)
if config().getdebug("ParallelExecution"):
debug("Command line:", " ".join(self.argv))
self.cmd = " ".join(self.argv)
foamLogger().info("Starting: " + self.cmd + " in " +
path.abspath(path.curdir))
self.logFile = path.join(self.dir, logname + ".logfile")
isRestart, restartnr, restartName, lastlog = findRestartFiles(
self.logFile, sol)
if restartName:
self.logFile = restartName
if not isRestart:
from os import unlink
from glob import glob
for g in glob(self.logFile + ".restart*"):
if path.isdir(g):
rmtree(g)
else:
unlink(g)
self.noLog = noLog
self.logTail = logTail
if self.logTail:
if self.noLog:
warning("Log tail", self.logTail,
"and no-log specified. Using logTail")
self.noLog = True
self.lastLines = []
self.compressLog = compressLog
if self.compressLog:
self.logFile += ".gz"
self.fatalError = False
self.fatalFPE = False
self.fatalStackdump = False
self.endSeen = False
self.warnings = 0
self.started = False
self.isRestarted = False
if restart:
self.controlDict = ParameterFile(path.join(self.dir, "system",
"controlDict"),
backup=True)
self.controlDict.replaceParameter("startFrom", "latestTime")
self.isRestarted = True
else:
self.controlDict = None
self.run = FoamThread(self.cmd, self)
self.server = None
if server:
self.server = FoamServer(run=self.run, master=self)
self.server.setDaemon(True)
self.server.start()
try:
IP, PID, Port = self.server.info()
f = open(path.join(self.dir, "PyFoamServer.info"), "w")
print_(IP, PID, Port, file=f)
f.close()
except AttributeError:
warning(
"There seems to be a problem with starting the server:",
self.server, "with attributes", dir(self.server))
self.server = None
self.createTime = None
self.nowTime = None
self.startTimestamp = time()
self.stopMe = False
self.writeRequested = False
self.endTriggers = []
self.lastLogLineSeen = None
self.lastTimeStepSeen = None
self.remark = remark
self.jobId = jobId
self.data = {"lines": 0} # self.data={"lines":0L}
self.data["logfile"] = self.logFile
self.data["casefullname"] = path.abspath(self.dir)
self.data["casename"] = path.basename(path.abspath(self.dir))
self.data["solver"] = path.basename(self.argv[0])
self.data["solverFull"] = self.argv[0]
self.data["commandLine"] = self.cmd
self.data["hostname"] = uname()[1]
if remark:
self.data["remark"] = remark
else:
self.data["remark"] = "No remark given"
if jobId:
self.data["jobId"] = jobId
parameterFile = sol.getParametersFromFile()
if len(parameterFile):
self.data["parameters"] = {}
for k, v in parameterFile.items():
self.data["parameters"][k] = makePrimitiveString(v)
if parameters:
if "parameters" not in self.data:
self.data["parameters"] = {}
self.data["parameters"].update(parameters)
self.data["starttime"] = asctime()
def start(self):
"""starts the command and stays with it till the end"""
self.started=True
if not self.noLog:
if self.compressLog:
fh=gzip.open(self.logFile,"w")
else:
fh=open(self.logFile,"w")
self.startHandle()
self.writeStartTime()
self.writeTheState("Running")
check=BasicRunnerCheck()
if self.echoCommandLine:
print_(self.echoCommandLine+" "+" ".join(self.argv))
self.run.start()
interrupted=False
totalWarningLines=0
addLinesToWarning=0
collectWarnings=True
while self.run.check():
try:
self.run.read()
if not self.run.check():
break
line=self.run.getLine()
if "errorText" in self.data:
self.data["errorText"]+=line+"\n"
if addLinesToWarning>0:
self.data["warningText"]+=line+"\n"
addLinesToWarning-=1
totalWarningLines+=1
if totalWarningLines>500:
collectWarnings=False
addLinesToWarning=0
self.data["warningText"]+="No more warnings added because limit of 500 lines exceeded"
self.data["lines"]+=1
self.lastLogLineSeen=time()
self.writeLastSeen()
tmp=check.getTime(line)
if check.controlDictRead(line):
if self.writeRequested:
duration=config().getfloat("Execution","controlDictRestoreWait",default=30.)
warning("Preparing to reset controlDict to old glory in",duration,"seconds")
Timer(duration,
restoreControlDict,
args=[self.controlDict,self]).start()
self.writeRequested=False
if tmp!=None:
self.data["time"]=tmp
self.nowTime=tmp
self.writeTheState("Running",always=False)
self.writeNowTime()
self.lastTimeStepSeen=time()
if self.createTime==None:
# necessary because interFoam reports no creation time
self.createTime=tmp
try:
self.data["stepNr"]+=1
except KeyError:
self.data["stepNr"]=1 # =1L
self.data["lasttimesteptime"]=asctime()
tmp=check.getCreateTime(line)
if tmp!=None:
self.createTime=tmp
if not self.silent:
try:
print_(line)
except IOError:
e = sys.exc_info()[1] # compatible with 2.x and 3.x
if e.errno!=32:
raise e
else:
# Pipe was broken
self.run.interrupt()
if line.find("FOAM FATAL ERROR")>=0 or line.find("FOAM FATAL IO ERROR")>=0:
self.fatalError=True
self.data["errorText"]="PyFoam found a Fatal Error "
if "time" in self.data:
self.data["errorText"]+="at time "+str(self.data["time"])+"\n"
else:
self.data["errorText"]+="before time started\n"
self.data["errorText"]+="\n"+line+"\n"
if line.find("Foam::sigFpe::sigFpeHandler")>=0:
self.fatalFPE=True
if line.find("Foam::error::printStack")>=0:
self.fatalStackdump=True
if self.fatalError and line!="":
foamLogger().error(line)
if line.find("FOAM Warning")>=0:
self.warnings+=1
try:
self.data["warnings"]+=1
except KeyError:
self.data["warnings"]=1
if collectWarnings:
addLinesToWarning=20
if not "warningText" in self.data:
self.data["warningText"]=""
else:
self.data["warningText"]+=("-"*40)+"\n"
self.data["warningText"]+="Warning found by PyFoam on line "
self.data["warningText"]+=str(self.data["lines"])+" "
if "time" in self.data:
self.data["warningText"]+="at time "+str(self.data["time"])+"\n"
else:
self.data["warningText"]+="before time started\n"
self.data["warningText"]+="\n"+line+"\n"
if self.server!=None:
self.server._insertLine(line)
self.lineHandle(line)
if not self.noLog:
fh.write(line+"\n")
fh.flush()
elif self.logTail:
self.appendTailLine(line)
except KeyboardInterrupt:
e = sys.exc_info()[1] # compatible with 2.x and 3.x
foamLogger().warning("Keyboard Interrupt")
self.run.interrupt()
self.writeTheState("Interrupted")
interrupted=True
self.data["interrupted"]=interrupted
self.data["OK"]=self.runOK()
self.data["cpuTime"]=self.run.cpuTime()
self.data["cpuUserTime"]=self.run.cpuUserTime()
self.data["cpuSystemTime"]=self.run.cpuSystemTime()
self.data["wallTime"]=self.run.wallTime()
self.data["usedMemory"]=self.run.usedMemory()
self.data["endtime"]=asctime()
self.data["fatalError"]=self.fatalError
self.data["fatalFPE"]=self.fatalFPE
self.data["fatalStackdump"]=self.fatalStackdump
self.writeNowTime(force=True)
self.stopHandle()
if not interrupted:
self.writeTheState("Finished")
for t in self.endTriggers:
t()
if not self.noLog:
fh.close()
elif self.logTail:
self.writeTailLog()
if self.server!=None:
self.server.deregister()
self.server.kill()
foamLogger().info("Finished")
return self.data
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,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 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 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 checkValid(self):
"""Check with server whether this data item is still valid"""
result=False
foamLogger("server").debug("Checking "+self["ip"]+"@"+str(self["port"]))
try:
server=getServerProxy(self["ip"],self["port"])
pid=server.pid()
if pid==self["pid"]:
result=True
except socket.timeout as reason:
foamLogger("server").info(self["ip"]+"@"+str(self["port"])+" seems to be dead")
except:
foamLogger("server").debug("Checking Valid "+self["ip"]+" failed:"+str(sys.exc_info()[0]))
foamLogger("server").debug("Reason:"+str(sys.exc_info()[1]))
foamLogger("server").debug("Trace:"+str(extract_tb(sys.exc_info()[2])))
foamLogger("server").debug("Result for "+self["ip"]+"@"+str(self["port"])+" = "+str(result))
return result
reg=Timer(5.,self.register)
reg.start()
self._running=True
try:
while self._running:
self._server.handle_request()
except select.error,e:
# 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
def kill(self):
"""Exits the server"""
foamLogger("server").warning("Terminating due to request")
t=Timer(1.,self._suicide)
t.start()
return True
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,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
