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): """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 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 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,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