def PRINT_TRACE(agent, bindings, event, expr, info=""): passes_filters = get_trace_filters().passes_filters(agent, bindings, event, expr, info) # check to see if we should do the effort of creating the debug string if not passes_filters and log_file is None: return try: varvals = variables(bindings, event, expr) except: errid = NEWPM.displayError() varvals = "ERROR PRINTING VARS" # kwc: i wrote the print to stdout and file this way so that there is a minimal # performance hit. the shorter way of writing this with just print statement # formatting was making the logging horribly slow. blevel = bindings_level(bindings) try: event_str = str(event) except: errid = NEWPM.displayError() event_str = "ERROR PRINTING EVENT" term_str = str(expr) vars_str = str(varvals) print_str = "*" * blevel + " " + event_str + " " + term_str + " BINDINGS: " + vars_str + info # trace filtering # - we filter stuff printed to stdout. # - everything gets logged to the logfile (no filtering) if passes_filters: print print_str if log_file is not None: log_file.write(print_str + "\n")
def resume_sources(): """resume loads any non-agent related persistence data. it is a pre-requisite to loading the agent KBs""" if not _resumeState: return console("Resuming sources...") persist_root_dir = get_persist_root_dir() persist_src_dir = get_persist_src_dir() if not os.path.exists(persist_root_dir) or not os.path.exists(persist_src_dir): console("Could not find %s or %s" % (persist_root_dir, persist_src_dir)) return try: from spark.internal.parse.processing import SPU_RECORD SPU_RECORD.restore() _init_resume_data() # set_resuming(True) # set_source_locator(persist__must_find_file) # _load_persisted_sources() _load_default_module() # set_source_locator(default__must_find_file) # set_resuming(False) console("DONE resuming sources") except AnyException, e: console("ERROR resuming sources") errid = NEWPM.displayError() NEWPM.pm(errid)
def recordIdUsed(self, id, obj): """Called when object is used""" if not self._info.has_key(id): # make sure that we don't loop when getting state info self._info[id] = None # get exists and state info # this will call recordIdUsed for anything obj references cl_name = obj.__class__.__name__ if not (CONSTRUCTOR_NAME_CLASS.has_key(cl_name)): print "ERROR: No constructor has been installed for %s"%cl_name try: existIEArgs = [inverse_eval(x) for x in obj.constructor_args()] existIEArgs.insert(0, cl_name) self._existsIEFacts.append((id, List(existIEArgs))) except: errid = NEWPM.displayError() print print "ERROR finding constructor_args() for instance %d of %s" \ % (id, cl_name) print try: state_args = obj.state_args() if state_args: stateIEArgs = [inverse_eval(x) for x in state_args] self._stateIEFacts.append((id, List(stateIEArgs))) except: errid = NEWPM.displayError() print print "ERROR finding state_args() for instance %d of %s" \ % (id, cl_name) print self._info[id] = obj
def resume_sources(): """resume loads any non-agent related persistence data. it is a pre-requisite to loading the agent KBs""" if not _resumeState: return console("Resuming sources...") persist_root_dir = get_persist_root_dir() persist_src_dir = get_persist_src_dir() if not os.path.exists(persist_root_dir) or not os.path.exists( persist_src_dir): console("Could not find %s or %s" % (persist_root_dir, persist_src_dir)) return try: from spark.internal.parse.processing import SPU_RECORD SPU_RECORD.restore() _init_resume_data() # set_resuming(True) # set_source_locator(persist__must_find_file) # _load_persisted_sources() _load_default_module() # set_source_locator(default__must_find_file) # set_resuming(False) console("DONE resuming sources") except AnyException, e: console("ERROR resuming sources") errid = NEWPM.displayError() NEWPM.pm(errid)
def recordIdUsed(self, id, obj): """Called when object is used""" if not self._info.has_key(id): # make sure that we don't loop when getting state info self._info[id] = None # get exists and state info # this will call recordIdUsed for anything obj references cl_name = obj.__class__.__name__ if not (CONSTRUCTOR_NAME_CLASS.has_key(cl_name)): print "ERROR: No constructor has been installed for %s" % cl_name try: existIEArgs = [inverse_eval(x) for x in obj.constructor_args()] existIEArgs.insert(0, cl_name) self._existsIEFacts.append((id, List(existIEArgs))) except: errid = NEWPM.displayError() print print "ERROR finding constructor_args() for instance %d of %s" \ % (id, cl_name) print try: state_args = obj.state_args() if state_args: stateIEArgs = [inverse_eval(x) for x in state_args] self._stateIEFacts.append((id, List(stateIEArgs))) except: errid = NEWPM.displayError() print print "ERROR finding state_args() for instance %d of %s" \ % (id, cl_name) print self._info[id] = obj
def PRINT_TRACE(agent, bindings, event, expr, info=""): passes_filters = get_trace_filters().passes_filters( agent, bindings, event, expr, info) #check to see if we should do the effort of creating the debug string if not passes_filters and log_file is None: return try: varvals = variables(bindings, event, expr) except: errid = NEWPM.displayError() varvals = "ERROR PRINTING VARS" # kwc: i wrote the print to stdout and file this way so that there is a minimal # performance hit. the shorter way of writing this with just print statement # formatting was making the logging horribly slow. blevel = bindings_level(bindings) try: event_str = str(event) except: errid = NEWPM.displayError() event_str = "ERROR PRINTING EVENT" term_str = str(expr) vars_str = str(varvals) print_str = "*" * blevel + ' ' + event_str + ' ' + term_str + ' BINDINGS: ' + vars_str + info # trace filtering # - we filter stuff printed to stdout. # - everything gets logged to the logfile (no filtering) if passes_filters: print print_str if log_file is not None: log_file.write(print_str + '\n')
def removeFile(filename): import os try: print "=== REMOVING FILE %s ===" % filename os.remove(filename) print "=== SUCCEEDED IN REMOVING FILE %s ===" % filename return True except: NEWPM.displayError() return False
def removeFile(filename): import os try: print "=== REMOVING FILE %s ==="%filename os.remove(filename) print "=== SUCCEEDED IN REMOVING FILE %s ==="%filename return True except: NEWPM.displayError() return False
def return_solutions(self): answer = IclList(self._answerlist) debug("ExternalSolve returning solutions %r", answer) try: self._oaa.oaaReturnDelayedSolutions(self._id, answer) debug("ExternalSolve called oaaReturnDelayedSolutions, %s, %s",\ self._id, answer) except AnyException: print "Exception while returning solutions to oaa", self._id NEWPM.displayError() debug("ExternalSolve return_solutions finishing")
def __XXXrepr__(self): try: if self._estack: return "<TF %s %s>" % (self._root_taskexpr, self._estack[-1]) elif self.completed(): return "<TF %s SUCCEEDED>" % (self._root_taskexpr,) else: return "<TF %s FAILED>" % (self._root_taskexpr,) except: NEWPM.displayError() return "!" + object.__repr__(self)
def __XXXrepr__(self): try: if self._estack: return "<TF %s %s>"%(self._root_taskexpr, \ self._estack[-1]) elif self.completed(): return "<TF %s SUCCEEDED>" % (self._root_taskexpr, ) else: return "<TF %s FAILED>" % (self._root_taskexpr, ) except: NEWPM.displayError() return "!" + object.__repr__(self)
def features(self, agent): try: sym = self.goalsym() if sym.modname is None: # DNM - Hack for @exteval return () facts = agent.factslist1(P_Features, sym) if facts: return facts[0][1] else: return () except: NEWPM.displayError() return ()
def task_icl_mode(agent, task, mode): try: kind = task.kind_string() namesym = task.goalsym() bindings = task.getBindings() patexprs = task.getZexpr() if not (isinstance(kind, basestring)): raise AssertionError if not (isSymbol(namesym)): raise AssertionError except AnyException: errid = NEWPM.displayError() return makeIclStr("<cannot handle task %s>"%task) try: return do_task_icl(agent, bindings, patexprs, kind, namesym, mode) except AnyException: errid = NEWPM.displayError() return "<err: %s>"%task
def optionalGetVariableValueString(bindings, var): try: return value_str(bindings.getVariableValue(ABSTRACT, var)) except LowError: errid = NEWPM.displayError() print "VARIABLE %s WAS NOT BOUND CORRECTLY!!!" % var return "???"
def load_module(agent, modname): chron = time.time() succeeds = 1 try: #PERSIST:INSTRUMENT report_instrumentation_point(agent, PRE_USER_MODULE_LOAD) mod = ensure_modpath_installed(Symbol(modname)) if not mod: print "=== COULD NOT INSTALL MODULE %s ==="%modname succeeds = 0 currMod = get_default_module() #check for equality here because we are reporting instrumentation points if mod is not currMod: set_default_module(mod) if not ensure_default_module_loaded(agent): print "=== COULD NOT LOAD MODULE %s ==="%modname succeeds = 0 #PERSIST:INSTRUMENT report_instrumentation_point(agent, POST_USER_MODULE_LOAD) except SPARKException: errid = NEWPM.displayError() chron = time.time() - chron print "Total Loading Time: %3.4f seconds."%chron #-*-*-*-*-*-* This is a hack to remove the logs from the console. A better solution is needed later. from spark.util.logger import get_sdl get_sdl().log("Default Module: %s", modname) return succeeds
def load_module(agent, modname): chron = time.time() succeeds = 1 try: # PERSIST:INSTRUMENT report_instrumentation_point(agent, PRE_USER_MODULE_LOAD) mod = ensure_modpath_installed(Symbol(modname)) if not mod: print "=== COULD NOT INSTALL MODULE %s ===" % modname succeeds = 0 currMod = get_default_module() # check for equality here because we are reporting instrumentation points if mod is not currMod: set_default_module(mod) if not ensure_default_module_loaded(agent): print "=== COULD NOT LOAD MODULE %s ===" % modname succeeds = 0 # PERSIST:INSTRUMENT report_instrumentation_point(agent, POST_USER_MODULE_LOAD) except SPARKException: errid = NEWPM.displayError() chron = time.time() - chron print "Total Loading Time: %3.4f seconds." % chron # -*-*-*-*-*-* This is a hack to remove the logs from the console. A better solution is needed later. from spark.util.logger import get_sdl get_sdl().log("Default Module: %s", modname) return succeeds
def process_result(self, agent, val): if not self._basicact._output_indices: # i.e., length == 0: # Note that a function returning None is treated as SUCCESS if val is False: result = MessageFailure(self, "%s implementing action returned False"%self._basicact.function_name()) elif isinstance(val, Failure): result = val else: result = SUCCESS elif self._basicact.bind_result(agent, self._bindings, self._zexpr, val): result = SUCCESS elif val == None: result = MessageFailure(self, "%s implementing action returned None" %self._basicact.function_name()) else: try: raise Exception("%s implementing action returned a value %r that does not match the output params %r"%(self._basicact.function_name(), val, self._basicact._output_indices)) except AnyException, e: errid = NEWPM.displayError() #@-timing# T_callfn.stop() #@-timing# T_processresult.start() # TODO: work out if this is the right way to handle this case new_err = CapturedError(self._zexpr, errid, "executing") self.process_exception(agent, new_err, errid) return
def predRetractall(agent, bindings, expr): imp = bindings.bImp(agent, expr) try: return imp.retractall(agent, bindings, expr) except NotLocatedError: errid = NEWPM.recordError() raise CapturedError(expr, errid, "retracting")
def task_icl_mode(agent, task, mode): try: kind = task.kind_string() namesym = task.goalsym() bindings = task.getBindings() patexprs = task.getZexpr() if not (isinstance(kind, basestring)): raise AssertionError if not (isSymbol(namesym)): raise AssertionError except AnyException: errid = NEWPM.displayError() return makeIclStr("<cannot handle task %s>" % task) try: return do_task_icl(agent, bindings, patexprs, kind, namesym, mode) except AnyException: errid = NEWPM.displayError() return "<err: %s>" % task
def predUpdate(agent, bindings, expr): imp = bindings.bImp(agent, expr) try: return imp.conclude(agent, bindings, expr) except NotLocatedError: errid = NEWPM.recordError() raise CapturedError(expr, errid, "concluding")
def task_pyMode(agent, task, mode): try: kind = task.kind_string() namesym = task.goalsym() bindings = task.getBindings() zexpr = task.getZexpr() patexprs = [zexpr[i] for i in range(len(zexpr))] if not (isinstance(kind, basestring)): raise AssertionError if not (isSymbol(namesym)): raise AssertionError except: NEWPM.displayError() return "<cannot handle task %s>"%task try: return do_task_py(agent, bindings, patexprs, kind, namesym, mode) except AnyException: NEWPM.displayError() return "<err: %s>"%task
def value_to_icl(self, value): from spark.io.oaa import InvalidTermError, value_to_icl try: return value_to_icl(value) except InvalidTermError: errid = NEWPM.displayError() result = "<NO ICL EQUIVALENT:%s>" % value_str(value) return value_to_icl(result)
def task_pyMode(agent, task, mode): try: kind = task.kind_string() namesym = task.goalsym() bindings = task.getBindings() zexpr = task.getZexpr() patexprs = [zexpr[i] for i in range(len(zexpr))] if not (isinstance(kind, basestring)): raise AssertionError if not (isSymbol(namesym)): raise AssertionError except: NEWPM.displayError() return "<cannot handle task %s>" % task try: return do_task_py(agent, bindings, patexprs, kind, namesym, mode) except AnyException: NEWPM.displayError() return "<err: %s>" % task
def value_to_icl(self, value): from spark.io.oaa import InvalidTermError, value_to_icl try: return value_to_icl(value) except InvalidTermError: errid = NEWPM.displayError() result = "<NO ICL EQUIVALENT:%s>"%value_str(value) return value_to_icl(result)
def resume_conclude(self, agent, bindings, zexpr): if (len(zexpr) != 2): raise AssertionError num = termEvalErr(agent, bindings, zexpr[0]) args = termEvalErr(agent, bindings, zexpr[1]) try: _ID_SAVE.constructIdObject(agent, num, *args) except: errid = NEWPM.displayError() raise LowError("Error recreating object %s %s [%s]"%(num, value_str(args), errid))
def writePredicates(agent, predicates, output, errOutput): """Write the current state of the given predicates to output. Report errors to errOutput.""" #Testing Script. Begin: # global chronometers #Testing Script. End. predimpls = [] for pred in predicates: impl = agent.getImp(pred) if impl is None: continue try: if isinstance(impl, PersistablePredImpInt) \ and impl.symbol not in SPU_LOAD_INFO_PREDICATES: predimpls.append(impl) except AnyException, f: NEWPM.displayError() errOutput.write('[%s.%s]: %s\n'%(pred.name, impl.__class__.__name__, str(f)))
def _dispatch(self, method, params): debug("incoming request method %r args %r", method, params) try: debug("Decoding parameters %r", params) decoded = decodeXMLValue(params) debug("Decoded parameters %r", decoded) (errnum, rid) = initiate_request(self.agent, S_XMLRPC, 0, method, decoded) except AnyException, e: errid = NEWPM.displayError() raise Fault(INTERNAL_ERROR, "Error [%s] %s"%(errid, e))
def pyMod(modname, funname): import sys try: __import__(modname) except ImportError, e: errid = NEWPM.recordError() #import traceback #print "EXCEPTION IN", self.name #traceback.print_exception(*self.exc_info) raise UnlocatedError("Error importing Python module %s:\n[%d] %s"%(modname, errid, e))
def resume_conclude(self, agent, bindings, zexpr): if (len(zexpr) != 2): raise AssertionError num = termEvalErr(agent, bindings, zexpr[0]) args = termEvalErr(agent, bindings, zexpr[1]) try: _ID_SAVE.constructIdObject(agent, num, *args) except: errid = NEWPM.displayError() raise LowError("Error recreating object %s %s [%s]" % (num, value_str(args), errid))
def run(self, *args): try: #print " Starting fun" self._thread_result = self._basicact._function(*args) #print " Finished fun" except AnyException, e: #print " Exception in fun" errid = NEWPM.displayError() self._thread_exception = e self._errid = errid
def find_tframes(self, agent): debug("DoEvent.find_tframes") try: imp = agent.getImp(self._symbol) tframes = imp.tframes(agent, self, self.getBindings(), self._taskexpr[0]) debug("DoEvent.find_tframes -> %s", tframes) return tframes except NotLocatedError, err: errid = NEWPM.recordError() raise CapturedError(self._taskexpr, errid, "doing")
def writePredicates(agent, predicates, output, errOutput): """Write the current state of the given predicates to output. Report errors to errOutput.""" #Testing Script. Begin: # global chronometers #Testing Script. End. predimpls = [] for pred in predicates: impl = agent.getImp(pred) if impl is None: continue try: if isinstance(impl, PersistablePredImpInt) \ and impl.symbol not in SPU_LOAD_INFO_PREDICATES: predimpls.append(impl) except AnyException, f: NEWPM.displayError() errOutput.write('[%s.%s]: %s\n' % (pred.name, impl.__class__.__name__, str(f)))
def __init__(self, location, extra = (), fn = None): ConstructibleValue.__init__(self) self._location = location ensure_dir(os.path.abspath(location)) self.name = "ExecutionTracer" self._desc = "ExecutionTracer" if os.path.isabs(location): # if it is not an absolute path: self.abs_location = location else: self.abs_location = os.path.join(get_persist_root_dir(), location) ensure_dir(self.abs_location) try: if fn != None and os.path.exists(self.abs_location + "/" + fn): # Reopen the old file resuming = True self._filename = fn ffn = self.abs_location + "/" + fn else: #Creating a new file. resuming = False self._filename = "sparklog_%04d%02d%02dT%02d%02d%02d.xml"%time.localtime()[0:6] ffn = self.abs_location + "/" + self._filename except: ConstructibleValue.__init__(self) NEWPM.displayError() debug("Error constructing the log file name.") return try: self.descriptor = FileWrapper(ffn, "a") self.writeLog("<?xml version=\"1.0\" ?>\n") self.writeLog("<ExecutionTracer>\n") if not resuming: global machineName self.writeLog("\t<Initiator>TaskManager</Initiator>\n") self.writeLog("\t<TimeZone>%s</TimeZone>\n"%time.tzname[0]) self.writeLog("\t<MachineName>%s</MachineName>\n"%machineName) for x in extra: key, value = x self.writeLog("\t<%s>%s</%s>\n"%(key, value, key)) except: NEWPM.displayError() debug("Error initiating the log file.")
def loadFactsFromFile(agent, filename, failedConcludes, diffIo, missingPredsList): from spark.internal.parse.basicvalues import VALUE_CONSTRUCTOR, Structure, isStructure from spark.internal.parse.generic_tokenizer import FileSource #from spark.internal.parse.sparkl_parser import EOF_DELIMITER, SPARKLTokenizer, SPARKLParser, BogusValue from spark.internal.parse.sparkl_parser import parseSPARKL from spark.lang.builtin_eval import builtin_evaluate from spark.internal.repr.varbindings import valuesBZ from spark.pylang.implementation import PersistablePredImpInt from spark.internal.parse.usagefuns import termEvalErr print "RESUMING KB FROM", filename #parser = SPARKLParser(VALUE_CONSTRUCTOR, SPARKLTokenizer(FileSource(filename))) #parseVal = parser.terms_and_taggeds(True, EOF_DELIMITER, "end of input") f = open(filename, 'rb') string = f.read() f.close() parseVal = parseSPARKL(string, "File "+filename, VALUE_CONSTRUCTOR) facts = [] # keep track of all facts in file for val in parseVal: # if isinstance(val, BogusValue): # bogusValues.append(val) # continue if not (isStructure(val)): raise AssertionError functor = val.functor try: imp = agent.getImp(functor) except LowError, e: if functor not in missingPredsList: #TODO: make warning only once per prediate functor console_warning("Predicate %s is no longer part of the SPARK process models and facts for it will be purged", functor.name) missingPredsList.append(functor) continue if not (isinstance(imp, PersistablePredImpInt)): raise AssertionError #evaluate each of the args before putting into the zexpr try: fact = [builtin_evaluate(agent, arg) for arg in val] facts.append(Structure(functor, fact)) b, z = valuesBZ(fact) except: errid = NEWPM.displayError() console_error("(persist) unable to resume knowledge base fact \n\t%s\n", val) continue bindings_altzexpr = imp.resume_conclude(agent, b, z) if bindings_altzexpr is not None: (bindings, altzexpr) = bindings_altzexpr failedConcludes.append((imp, bindings, altzexpr,)) diffIo.write("-(%s %s)\n"%(val.functor.name, \ " ".join([persist_strrep(v) for v in val]))) diffIo.write("+(%s %s)\n"%(val.functor.name, \ " ".join([persist_strrep(termEvalErr(agent, bindings, z)) for z in altzexpr])))
def pyMod(modname, funname): import sys try: __import__(modname) except ImportError, e: errid = NEWPM.recordError() #import traceback #print "EXCEPTION IN", self.name #traceback.print_exception(*self.exc_info) raise UnlocatedError("Error importing Python module %s:\n[%d] %s" % (modname, errid, e))
def NO_TRACE(agent, bindings, event, expr, info=""): # even though we're not tracing, still have to log if log_file is None: return try: varvals = variables(bindings, event, expr) except: errid = NEWPM.displayError() varvals = "ERROR PRINTING VARS" blevel = bindings_level(bindings) event_str = str(event) term_str = str(expr) vars_str = str(varvals) log_file.write("*" * blevel + " " + event_str + " " + term_str + " BINDINGS: " + vars_str + info + "\n")
class BasicImpTFrame(TFrame): __slots__ = ( "_basicact", "_bindings", "_zexpr", ) def cvname(self): return self._basicact.cvname() def __init__(self, name, event, basicact, bindings, zexpr): TFrame.__init__(self, name, event) self._basicact = basicact self._bindings = bindings self._zexpr = zexpr def constructor_args(self): return TFrame.constructor_args(self) + [self._basicact, self._bindings, self._zexpr] constructor_mode = "VIIIV" def tfcont(self, agent): #@-timing# T_tfcont.start() try: #debug("Creating args for %r", self) #@-timing# T_genargs.start() args = self._basicact.generate_args(agent, self._bindings, self._zexpr) #@-timing# T_genargs.stop() #debug("Calling %r on %r", self._basicact._function, args) #@-timing# T_callfn.start() val = self._basicact._function(*args) #@-timing# T_callfn.stop() except LocatedError, e: errid = NEWPM.displayError() #@-timing# T_callfn.stop() #@-timing# T_processresult.start() self.process_exception(agent, e, errid) #@-timing# T_processresult.stop() #@-timing# T_tfcont.stop() return except AnyException, e: errid = NEWPM.displayError() #@-timing# T_callfn.stop() #@-timing# T_processresult.start() # TODO: work out if this is the right way to handle this case new_err = CapturedError(self._zexpr, errid, "executing") self.process_exception(agent, new_err, errid) #@-timing# T_processresult.stop() #@-timing# T_tfcont.stop() return
def NO_TRACE(agent, bindings, event, expr, info=""): #even though we're not tracing, still have to log if log_file is None: return try: varvals = variables(bindings, event, expr) except: errid = NEWPM.displayError() varvals = "ERROR PRINTING VARS" blevel = bindings_level(bindings) event_str = str(event) term_str = str(expr) vars_str = str(varvals) log_file.write("*" * blevel + ' ' + event_str + ' ' + term_str + ' BINDINGS: ' + vars_str + info + '\n')
def predSolve1(agent, bindings, expr): imp = bindings.bImp(agent, expr) try: if _tracing: _tracing.do_try(agent, bindings, expr) x = imp.solution(agent, bindings, expr) if x: _tracing.do_succeed(agent, bindings, expr) return x _tracing.do_fail(agent, bindings, expr) else: return imp.solution(agent, bindings, expr) except NotLocatedError: errid = NEWPM.recordError() raise CapturedError(expr, errid, "solving")
def predSolve(agent, bindings, expr): imp = bindings.bImp(agent, expr) try: if _tracing: _tracing.do_try(agent, bindings, expr) for x in imp.solutions(agent, bindings, expr): if x: _tracing.do_succeed(agent, bindings, expr) yield x _tracing.do_retry(agent, bindings, expr) _tracing.do_fail(agent, bindings, expr) else: for x in imp.solutions(agent, bindings, expr): yield x except NotLocatedError: errid = NEWPM.recordError() raise CapturedError(expr, errid, "solving")
def tfcont(self, agent): """tfcont will call agent.setChanged if something changed""" debug("=> tfcont - TOS=%r", self._estack[-1]) if self._subgoal_event: # subgoal has not been processed debug("== tfcont - existing subgoal = %r", self._subgoal_event) failure = NoGoalResponseFailure(self, self._subgoal_event) return self.tfhandlecfin(agent, self._subgoal_event, failure) else: try: taskexpr = self._estack[-1] debug("=== .tresume %r", taskexpr) imp = taskImp(agent, self, taskexpr) return imp.tresume(agent, self, taskexpr) except AnyException, err: estack = self._estack[:] # a copy for when we debug errid = NEWPM.displayError() # we are trapping error so print it failure = ExceptionFailure(self, err, errid) return self.tfcompleted(agent, failure)
def doOAAEvent(self, goal, params, _answers): debug("doOAAEvent(%r, %r, %r)", goal, params, _answers) try: goalname = getFunctor(goal) logInfo("doOAAEvent[%s]"%goalname) if goalname == "ev_solved": print "skipping the ev_solved: %s"%goal return True ext = ExternalSolve(self._oaa, goal, params) debug("doOAAEvent calling oaadelaySolution") self._oaa.oaaDelaySolution(ext.get_id()) debug("doOAAEvent adding external %r", ext.get_id()) self._agent.add_external(ext) return True except AnyException: #print "Rejected OAA request" errid = NEWPM.displayError() return False
def doOAAEvent(self, goal, params, _answers): debug("doOAAEvent(%r, %r, %r)", goal, params, _answers) try: goalname = getFunctor(goal) logInfo("doOAAEvent[%s]" % goalname) if goalname == "ev_solved": print "skipping the ev_solved: %s" % goal return True ext = ExternalSolve(self._oaa, goal, params) debug("doOAAEvent calling oaadelaySolution") self._oaa.oaaDelaySolution(ext.get_id()) debug("doOAAEvent adding external %r", ext.get_id()) self._agent.add_external(ext) return True except AnyException: #print "Rejected OAA request" errid = NEWPM.displayError() return False
def persist_point(agent, point): #print "persist_point()" try: #the instrumentation layer has already verified that is_persist_point() is #True, so we can just directly call persist_kb() from here if we're not #in a resuming state if not is_resuming() and _persistState: #print "persist_point()" persist_version() #print "persist_version() complete" persist_kb(agent) #print "persist_kb() complete" persist_default_module() #print "persist_point() complete" except: #we can't allow the persist operation to fubar the executor state, so we catch #and print here for now errid = NEWPM.displayError()
def initial_sdl(logParams={}): global sdlogger name = "SDL" if not logParams.has_key('sparkhome'): from spark.util.misc import getSparkHomeDirectory logParams['sparkhome'] = getSparkHomeDirectory() if not logParams.has_key('logdir'): # Create log directory if not present logParams['logdir'] = os.path.join(logParams['sparkhome'], "log") #keep logging.config happy since it expects string literals logParams['logdir'] = logParams['logdir'].replace("\\", "\\\\") # print "logdir=", logParams['logdir'] # print "sparkhome=", logParams['sparkhome'] from spark.internal.persist_aux import ensure_dir ensure_dir(logParams['logdir']) # try: import logging.config config_log_file = os.path.join(logParams['sparkhome'], "config", "logger.cfg") if os.path.isfile(config_log_file): logging.config.fileConfig(config_log_file, logParams) else: # Use default setting if it can not find the config file print "Could not find %s. Using default logger configuration..." % config_log_file logger = logging.getLogger(name) sparklog = os.path.join(logParams['logdir'], 'spark.log') #print "sparklog=", sparklog hdlr = logging.FileHandler(sparklog) formatter = logging.Formatter( '%(created)f [%(thread)d] %(levelname)s %(name)s - %(message)s' ) hdlr.setFormatter(formatter) logger.addHandler(hdlr) print "%s initiated." % name except AnyException, e: errid = NEWPM.displayError() print "Error initiating %s." % e
def tfcont(self, agent): """tfcont will call agent.setChanged if something changed""" debug("=> tfcont - TOS=%r", self._estack[-1]) if self._subgoal_event: # subgoal has not been processed debug("== tfcont - existing subgoal = %r", self._subgoal_event) failure = NoGoalResponseFailure(self, self._subgoal_event) return self.tfhandlecfin(agent, self._subgoal_event, failure) else: try: taskexpr = self._estack[-1] debug("=== .tresume %r", taskexpr) imp = taskImp(agent, self, taskexpr) return imp.tresume(agent, self, taskexpr) except AnyException, err: estack = self._estack[:] # a copy for when we debug errid = NEWPM.displayError( ) # we are trapping error so print it failure = ExceptionFailure(self, err, errid) return self.tfcompleted(agent, failure)
def tfcont(self, agent): #@-timing# T_tfcont.start() try: #debug("Creating args for %r", self) #@-timing# T_genargs.start() args = self._basicact.generate_args(agent, self._bindings, self._zexpr) #@-timing# T_genargs.stop() #debug("Calling %r on %r", self._basicact._function, args) #@-timing# T_callfn.start() val = self._basicact._function(*args) #@-timing# T_callfn.stop() except LocatedError, e: errid = NEWPM.displayError() #@-timing# T_callfn.stop() #@-timing# T_processresult.start() self.process_exception(agent, e, errid) #@-timing# T_processresult.stop() #@-timing# T_tfcont.stop() return