def sm_eval(self, plan, input_state):
def be_task(prim_name, fn, api, **kwargs):
def wrapped(input_state, **outer_args):
kwargs.update(outer_args)
return self.backend_wrapper(input_state, prim_name, fn, api, **kwargs)
return wrapped
self.logger.info("building state machine for %s" % plan)
sm = StateMachine(input_state)
sm.set_state("state_0")
for state_index, state in enumerate(plan):
parameters = state["ns"]
primitive = state["primitive"]
timeout = state.get("timeout", 30)
self.logger.debug("padding globals %s" % self.adventure_globals)
parameters["globals"] = self.adventure_globals
parameters["globals"]["parent_task_id"] = self.parent_task_id
self.logger.debug("Wrapping %s primitive" % primitive)
if "." in primitive:
# this primitive comes from backends
backend_fn = opencenter.backends.primitive_by_name(primitive)
if not backend_fn:
msg = 'cannot find backend primitive "%s"' % primitive
self.logger.debug(msg)
input_state["fails"] = input_state["nodes"]
input_state["nodes"] = []
return ({"result_code": 1, "result_str": msg, "result_data": {}}, input_state)
fn = be_task(primitive, backend_fn, self.api, **parameters)
else:
# this primitive comes from node tasks.
parameters["timeout"] = timeout
run_task = "agent.run_task"
backend_fn = opencenter.backends.primitive_by_name(run_task)
fn = be_task("agent.run_task", backend_fn, self.api, **{"action": primitive, "payload": parameters})
# we have the backend fn, now wrap it up.
# solver plans are linear, so we'll jump to next step always
# plus, we'll assume that failure goes to default failure case
next_state = state_index + 1
success_state = "state_%d" % next_state
if (next_state) == len(plan):
success_state = "success"
sm.add_state("state_%d" % state_index, StateMachineState(advance=fn, on_success=success_state))
result_data, end_state = sm.run_to_completion()
return (result_data, end_state)
def sm_eval(self, plan, input_state):
def be_task(prim_name, fn, api, **kwargs):
def wrapped(input_state, **outer_args):
kwargs.update(outer_args)
return self.backend_wrapper(input_state, prim_name,
fn, api, **kwargs)
return wrapped
self.logger.info('building state machine for %s' % plan)
sm = StateMachine(input_state)
sm.set_state('state_0')
for state_index, state in enumerate(plan):
parameters = state['ns']
primitive = state['primitive']
timeout = state.get('timeout', 30)
self.logger.debug('padding globals %s' % self.adventure_globals)
parameters['globals'] = self.adventure_globals
parameters['globals']['parent_task_id'] = self.parent_task_id
self.logger.debug('Wrapping %s primitive' % primitive)
if '.' in primitive:
# this primitive comes from backends
backend_fn = opencenter.backends.primitive_by_name(primitive)
if not backend_fn:
msg = 'cannot find backend primitive "%s"' % primitive
self.logger.debug(msg)
input_state['fails'] = input_state['nodes']
input_state['nodes'] = []
return({'result_code': 1,
'result_str': msg,
'result_data': {}}, input_state)
fn = be_task(primitive, backend_fn, self.api, **parameters)
else:
# this primitive comes from node tasks.
parameters['timeout'] = timeout
run_task = 'agent.run_task'
backend_fn = opencenter.backends.primitive_by_name(run_task)
fn = be_task('agent.run_task', backend_fn, self.api,
**{'action': primitive,
'payload': parameters})
# we have the backend fn, now wrap it up.
# solver plans are linear, so we'll jump to next step always
# plus, we'll assume that failure goes to default failure case
next_state = state_index + 1
success_state = 'state_%d' % next_state
if(next_state) == len(plan):
success_state = 'success'
sm.add_state(
'state_%d' % state_index, StateMachineState(
advance=fn,
on_success=success_state))
result_data, end_state = sm.run_to_completion()
return (result_data, end_state)
def sm_eval(self, plan, input_state):
def be_task(prim_name, fn, api, **kwargs):
def wrapped(input_state, **outer_args):
kwargs.update(outer_args)
return self.backend_wrapper(input_state, prim_name, fn, api,
**kwargs)
return wrapped
self.logger.info('building state machine for %s' % plan)
sm = StateMachine(input_state)
sm.set_state('state_0')
for state_index, state in enumerate(plan):
parameters = state['ns']
primitive = state['primitive']
timeout = state.get('timeout', 30)
self.logger.debug('padding globals %s' % self.adventure_globals)
parameters['globals'] = self.adventure_globals
parameters['globals']['parent_task_id'] = self.parent_task_id
self.logger.debug('Wrapping %s primitive' % primitive)
if '.' in primitive:
# this primitive comes from backends
backend_fn = opencenter.backends.primitive_by_name(primitive)
if not backend_fn:
msg = 'cannot find backend primitive "%s"' % primitive
self.logger.debug(msg)
input_state['fails'] = input_state['nodes']
input_state['nodes'] = []
return ({
'result_code': 1,
'result_str': msg,
'result_data': {}
}, input_state)
fn = be_task(primitive, backend_fn, self.api, **parameters)
else:
# this primitive comes from node tasks.
parameters['timeout'] = timeout
run_task = 'agent.run_task'
backend_fn = opencenter.backends.primitive_by_name(run_task)
fn = be_task('agent.run_task', backend_fn, self.api, **{
'action': primitive,
'payload': parameters
})
# we have the backend fn, now wrap it up.
# solver plans are linear, so we'll jump to next step always
# plus, we'll assume that failure goes to default failure case
next_state = state_index + 1
success_state = 'state_%d' % next_state
if (next_state) == len(plan):
success_state = 'success'
sm.add_state(
'state_%d' % state_index,
StateMachineState(advance=fn, on_success=success_state))
result_data, end_state = sm.run_to_completion()
return (result_data, end_state)
