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 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 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 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 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 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 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 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 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
